wikiparser-node 1.2.0-b → 1.2.0

package/dist/src/converterFlags.js

@@ -0,0 +1,223 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConverterFlagsToken = void 0;
+const lint_1 = require("../util/lint");
+const debug_1 = require("../util/debug");
+const constants_1 = require("../util/constants");
+const Parser = require("../index");
+const index_1 = require("./index");
+const atom_1 = require("./atom");
+const definedFlags = new Set(['A', 'T', 'R', 'D', '-', 'H', 'N']);
+/**
+ * 转换flags
+ * @classdesc `{childNodes: ...AtomToken}`
+ */
+class ConverterFlagsToken extends index_1.Token {
+    type = 'converter-flags';
+    #flags;
+    /* NOT FOR BROWSER */
+    /** 所有转换类型标记 */
+    get flags() {
+        return this.getAllFlags();
+    }
+    set flags(value) {
+        this.replaceChildren();
+        for (const flag of value) {
+            this.#newFlag(flag);
+        }
+    }
+    /** @param flags 转换类型标记 */
+    constructor(flags, config = Parser.getConfig(), accum = []) {
+        super(undefined, config, accum, {
+            AtomToken: ':',
+        });
+        this.append(...flags.map(flag => new atom_1.AtomToken(flag, 'converter-flag', config, accum)));
+    }
+    /** @private */
+    afterBuild() {
+        this.#flags = this.childNodes.map(child => child.text().trim());
+        const /** @implements */ converterFlagsListener = ({ prevTarget }) => {
+            if (prevTarget) {
+                this.#flags[this.childNodes.indexOf(prevTarget)] = prevTarget.text().trim();
+            }
+        };
+        this.addEventListener(['remove', 'insert', 'text', 'replace'], converterFlagsListener);
+    }
+    /** @private */
+    toString(omit) {
+        return super.toString(omit, ';');
+    }
+    /** @override */
+    text() {
+        return super.text(';');
+    }
+    /** @private */
+    getGaps() {
+        return 1;
+    }
+    /** 获取未知的转换类型标记 */
+    getUnknownFlags() {
+        return new Set(this.#flags.filter(flag => /\{{3}[^{}]+\}{3}/u.test(flag)));
+    }
+    /** 获取指定语言变体的转换标记 */
+    getVariantFlags() {
+        const variants = new Set(this.getAttribute('config').variants);
+        return new Set(this.#flags.filter(flag => variants.has(flag)));
+    }
+    /** @override */
+    lint(start = this.getAbsoluteIndex()) {
+        const variantFlags = this.getVariantFlags(), unknownFlags = this.getUnknownFlags(), validFlags = new Set(this.#flags.filter(flag => definedFlags.has(flag))), { length: emptyFlagCount } = this.#flags.filter(flag => !flag), knownFlagCount = this.#flags.length - unknownFlags.size - emptyFlagCount, errors = super.lint(start);
+        if (variantFlags.size === knownFlagCount || validFlags.size === knownFlagCount) {
+            return errors;
+        }
+        const rect = { start, ...this.getRootNode().posFromIndex(start) }, { childNodes, length } = this;
+        for (let i = 0; i < length; i++) {
+            const child = childNodes[i], flag = child.text().trim();
+            if (flag && !variantFlags.has(flag) && !unknownFlags.has(flag)
+                && (variantFlags.size > 0 || !validFlags.has(flag))) {
+                const error = (0, lint_1.generateForChild)(child, rect, 'invalid conversion flag');
+                errors.push({ ...error, excerpt: childNodes.slice(0, i + 1).map(String).join(';').slice(-50) });
+            }
+        }
+        return errors;
+    }
+    /** @override */
+    print() {
+        return super.print({ sep: ';' });
+    }
+    /* NOT FOR BROWSER */
+    /** @override */
+    cloneNode() {
+        const cloned = this.cloneChildNodes();
+        return debug_1.Shadow.run(() => {
+            const token = new ConverterFlagsToken([], this.getAttribute('config'));
+            token.append(...cloned);
+            token.afterBuild();
+            return token;
+        });
+    }
+    /** @private */
+    getAttribute(key) {
+        return key === 'flags' ? this.#flags : super.getAttribute(key);
+    }
+    /**
+     * @override
+     * @param i 移除位置
+     */
+    removeAt(i) {
+        const token = super.removeAt(i);
+        this.#flags?.splice(i, 1);
+        return token;
+    }
+    /**
+     * @override
+     * @param token 待插入的子节点
+     * @param i 插入位置
+     */
+    insertAt(token, i = this.length) {
+        super.insertAt(token, i);
+        this.#flags?.splice(i, 0, token.text().trim());
+        return token;
+    }
+    /** 获取所有转换类型标记 */
+    getAllFlags() {
+        return new Set(this.#flags);
+    }
+    /**
+     * 获取转换类型标记节点
+     * @param flag 转换类型标记
+     */
+    getFlagTokens(flag) {
+        return this.#flags.includes(flag) ? this.childNodes.filter(child => child.text().trim() === flag) : [];
+    }
+    /** 获取有效的转换类型标记 */
+    getEffectiveFlags() {
+        const variantFlags = this.getVariantFlags(), unknownFlags = this.getUnknownFlags();
+        if (variantFlags.size > 0) {
+            return new Set([...variantFlags, ...unknownFlags]);
+        }
+        const flags = new Set([...this.#flags.filter(flag => definedFlags.has(flag)), ...unknownFlags]);
+        if (flags.size === 0) {
+            return new Set('S');
+        }
+        else if (flags.has('R')) {
+            return new Set('R');
+        }
+        else if (flags.has('N')) {
+            return new Set('N');
+        }
+        else if (flags.has('-')) {
+            return new Set('-');
+        }
+        else if (flags.has('H')) {
+            const hasT = flags.has('T'), hasD = flags.has('D');
+            return hasT && hasD
+                ? new Set(['+', 'H', 'T', 'D'])
+                : new Set(['+', 'H', ...hasT ? ['T'] : [], ...hasD ? ['D'] : [], ...unknownFlags]);
+        }
+        if (flags.size === 1 && flags.has('T')) {
+            flags.add('H');
+        }
+        if (flags.has('A')) {
+            flags.add('+');
+            flags.add('S');
+        }
+        if (flags.has('D')) {
+            flags.delete('S');
+        }
+        return flags;
+    }
+    /**
+     * 是否具有某转换类型标记
+     * @param flag 转换类型标记
+     */
+    hasFlag(flag) {
+        return this.#flags.includes(flag);
+    }
+    /**
+     * 是否具有某有效的转换类型标记
+     * @param flag 转换类型标记
+     */
+    hasEffectiveFlag(flag) {
+        return this.getEffectiveFlags().has(flag);
+    }
+    /**
+     * 移除某转换类型标记
+     * @param flag 转换类型标记
+     */
+    removeFlag(flag) {
+        for (const token of this.getFlagTokens(flag)) {
+            token.remove();
+        }
+    }
+    /**
+     * 添加转换类型标记
+     * @param flag 转换类型标记
+     */
+    #newFlag(flag) {
+        this.insertAt(debug_1.Shadow.run(() => new atom_1.AtomToken(flag, 'converter-flag', this.getAttribute('config'))));
+    }
+    /**
+     * 设置转换类型标记
+     * @param flag 转换类型标记
+     */
+    setFlag(flag) {
+        if (!this.#flags.includes(flag)) {
+            this.#newFlag(flag);
+        }
+    }
+    /**
+     * 开关转换类型标记
+     * @param flag 转换类型标记
+     */
+    toggleFlag(flag) {
+        if (this.#flags.includes(flag)) {
+            this.removeFlag(flag);
+        }
+        else {
+            this.#newFlag(flag);
+        }
+    }
+}
+exports.ConverterFlagsToken = ConverterFlagsToken;
+constants_1.classes['ConverterFlagsToken'] = __filename;

package/dist/src/converterRule.d.ts

@@ -0,0 +1,81 @@
+import * as Parser from '../index';
+import { Token } from './index';
+import { AtomToken } from './atom';
+import type { ConverterToken, ConverterFlagsToken } from '../internal';
+/**
+ * 转换规则
+ * @classdesc `{childNodes: ...AtomToken}`
+ */
+export declare class ConverterRuleToken extends Token {
+    readonly type = "converter-rule";
+    readonly childNodes: [AtomToken] | [AtomToken, AtomToken] | [AtomToken, AtomToken, AtomToken];
+    abstract get children(): [AtomToken] | [AtomToken, AtomToken] | [AtomToken, AtomToken, AtomToken];
+    abstract get firstChild(): AtomToken;
+    abstract get firstElementChild(): AtomToken;
+    abstract get lastChild(): AtomToken;
+    abstract get lastElementChild(): AtomToken;
+    abstract get parentNode(): ConverterToken | undefined;
+    abstract get parentElement(): ConverterToken | undefined;
+    abstract get previousSibling(): ConverterFlagsToken | this;
+    abstract get previousElementSibling(): ConverterFlagsToken | this;
+    abstract get nextSibling(): this | undefined;
+    abstract get nextElementSibling(): this | undefined;
+    /** 语言变体 */
+    get variant(): string;
+    set variant(variant: string);
+    /** 是否是单向转换 */
+    get unidirectional(): boolean;
+    /** @throws `Error` 不能用于将双向转换或不转换更改为单向转换 */
+    set unidirectional(flag: boolean);
+    /** 是否是双向转换 */
+    get bidirectional(): boolean;
+    /** @throws `Error` 不能用于将双向转换更改为单向转换或将不转换更改为双向转换 */
+    set bidirectional(flag: boolean);
+    /**
+     * @param rule 转换规则
+     * @param hasColon 是否带有":"
+     */
+    constructor(rule: string, hasColon?: boolean, config?: Parser.Config, accum?: Token[]);
+    /** @override */
+    text(): string;
+    /** @override */
+    print(): string;
+    /** @override */
+    cloneNode(): this;
+    /**
+     * @override
+     * @param i 移除位置
+     * @throws `Error` 至少保留1个子节点
+     */
+    removeAt(i: number): AtomToken;
+    /**
+     * @override
+     * @throws `Error` 请勿手动插入子节点
+     */
+    insertAt(): never;
+    /** 修改为不转换 */
+    noConvert(): void;
+    /**
+     * 设置转换目标
+     * @param to 转换目标
+     */
+    setTo(to: string): void;
+    /**
+     * 设置语言变体
+     * @param variant 语言变体
+     */
+    setVariant(variant: string): void;
+    /**
+     * 设置转换原文
+     * @param from 转换原文
+     * @throws `Error` 尚未指定语言变体
+     */
+    setFrom(from: string): void;
+    /**
+     * 修改为单向转换
+     * @param from 转换原文
+     */
+    makeUnidirectional(from: string): void;
+    /** 修改为双向转换 */
+    makeBidirectional(): void;
+}

package/dist/src/converterRule.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConverterRuleToken = void 0;
+const debug_1 = require("../util/debug");
+const constants_1 = require("../util/constants");
+const Parser = require("../index");
+const index_1 = require("./index");
+const atom_1 = require("./atom");
+/**
+ * 转换规则
+ * @classdesc `{childNodes: ...AtomToken}`
+ */
+class ConverterRuleToken extends index_1.Token {
+    type = 'converter-rule';
+    /* NOT FOR BROWSER */
+    /** 语言变体 */
+    get variant() {
+        return this.childNodes.at(-2)?.text().trim() ?? '';
+    }
+    set variant(variant) {
+        this.setVariant(variant);
+    }
+    /** 是否是单向转换 */
+    get unidirectional() {
+        return this.length === 3;
+    }
+    /** @throws `Error` 不能用于将双向转换或不转换更改为单向转换 */
+    set unidirectional(flag) {
+        const { length } = this;
+        if (length === 3 && !flag) {
+            this.makeBidirectional();
+        }
+        else if (length === 2 && flag) {
+            throw new Error('想更改为单向转换请使用 makeUnidirectional 方法！');
+        }
+        else if (length === 1 && flag) {
+            throw new Error('想更改为单向转换请先使用 setVariant 方法指定语言变体！');
+        }
+    }
+    /** 是否是双向转换 */
+    get bidirectional() {
+        return this.length === 2;
+    }
+    /** @throws `Error` 不能用于将双向转换更改为单向转换或将不转换更改为双向转换 */
+    set bidirectional(flag) {
+        const { length } = this;
+        if (length === 3 && flag) {
+            this.makeBidirectional();
+        }
+        else if (length === 2 && !flag) {
+            throw new Error('想更改为单向转换请使用 makeUnidirectional 方法！');
+        }
+        else if (length === 1 && flag) {
+            throw new Error('想更改为双向转换请使用 setVariant 方法！');
+        }
+    }
+    /* NOT FOR BROWSER END */
+    /**
+     * @param rule 转换规则
+     * @param hasColon 是否带有":"
+     */
+    constructor(rule, hasColon = true, config = Parser.getConfig(), accum = []) {
+        super(undefined, config, accum);
+        const i = rule.indexOf(':'), j = rule.slice(0, i).indexOf('=>'), v = j === -1 ? rule.slice(0, i) : rule.slice(j + 2, i);
+        if (hasColon && config.variants.includes(v.trim())) {
+            super.insertAt(new atom_1.AtomToken(v, 'converter-rule-variant', config, accum));
+            super.insertAt(new atom_1.AtomToken(rule.slice(i + 1), 'converter-rule-to', config, accum));
+            if (j !== -1) {
+                super.insertAt(new atom_1.AtomToken(rule.slice(0, j), 'converter-rule-from', config, accum), 0);
+            }
+        }
+        else {
+            super.insertAt(new atom_1.AtomToken(rule, 'converter-rule-to', config, accum));
+        }
+        this.protectChildren('1:');
+    }
+    /** @private */
+    toString(omit) {
+        const { childNodes } = this;
+        if (childNodes.length === 3 && !(omit && this.matchesTypes(omit))) {
+            const [from, variant, to] = childNodes;
+            return `${from.toString(omit)}=>${variant.toString(omit)}:${to.toString(omit)}`;
+        }
+        return super.toString(omit, ':');
+    }
+    /** @override */
+    text() {
+        const { childNodes } = this;
+        if (childNodes.length === 3) {
+            const [from, variant, to] = childNodes;
+            return `${from.text()}=>${variant.text()}:${to.text()}`;
+        }
+        return super.text(':');
+    }
+    /** @private */
+    getGaps(i) {
+        return i === 0 && this.length === 3 ? 2 : 1;
+    }
+    /** @override */
+    print() {
+        const { childNodes } = this;
+        if (childNodes.length === 3) {
+            const [from, variant, to] = childNodes;
+            return `<span class="wpb-converter-rule">${from.print()}=>${variant.print()}:${to.print()}</span>`;
+        }
+        return super.print({ sep: ':' });
+    }
+    /* NOT FOR BROWSER */
+    /** @override */
+    cloneNode() {
+        const cloned = this.cloneChildNodes(), placeholders = ['', 'zh:', '=>zh:'], placeholder = placeholders[cloned.length - 1];
+        return debug_1.Shadow.run(() => {
+            const token = new ConverterRuleToken(placeholder, Boolean(placeholder), this.getAttribute('config'));
+            for (let i = 0; i < cloned.length; i++) {
+                token.childNodes[i].safeReplaceWith(cloned[i]);
+            }
+            token.afterBuild();
+            return token;
+        });
+    }
+    /** @private */
+    afterBuild() {
+        const /** @implements */ converterRuleListener = (e, data) => {
+            const { prevTarget } = e;
+            if (this.length > 1 && this.childNodes.at(-2) === prevTarget) {
+                const { variant } = this;
+                if (!this.getAttribute('config').variants.includes(variant)) {
+                    (0, debug_1.undo)(e, data);
+                    throw new Error(`无效的语言变体：${variant}`);
+                }
+            }
+        };
+        this.addEventListener(['remove', 'insert', 'text', 'replace'], converterRuleListener);
+    }
+    /**
+     * @override
+     * @param i 移除位置
+     * @throws `Error` 至少保留1个子节点
+     */
+    removeAt(i) {
+        if (this.length === 1) {
+            throw new Error(`${this.constructor.name} 需至少保留 1 个子节点！`);
+        }
+        return super.removeAt(i);
+    }
+    /**
+     * @override
+     * @throws `Error` 请勿手动插入子节点
+     */
+    insertAt() {
+        throw new Error(`转换规则语法复杂，请勿尝试对 ${this.constructor.name} 手动插入子节点！`);
+    }
+    /** 修改为不转换 */
+    noConvert() {
+        const { length } = this;
+        for (let i = 0; i < length - 1; i++) { // ConverterRuleToken只能从前往后删除子节点
+            this.removeAt(0);
+        }
+    }
+    /**
+     * 设置转换目标
+     * @param to 转换目标
+     */
+    setTo(to) {
+        const { childNodes } = Parser.parse(to, this.getAttribute('include'), undefined, this.getAttribute('config'));
+        this.lastChild.replaceChildren(...childNodes);
+    }
+    /**
+     * 设置语言变体
+     * @param variant 语言变体
+     */
+    setVariant(variant) {
+        const config = this.getAttribute('config');
+        if (this.length === 1) {
+            super.insertAt(debug_1.Shadow.run(() => new atom_1.AtomToken(variant, 'converter-rule-variant', config)), 0);
+        }
+        else {
+            this.childNodes.at(-2).setText(variant);
+        }
+    }
+    /**
+     * 设置转换原文
+     * @param from 转换原文
+     * @throws `Error` 尚未指定语言变体
+     */
+    setFrom(from) {
+        const { variant, unidirectional } = this;
+        if (!variant) {
+            throw new Error('请先指定语言变体！');
+        }
+        const config = this.getAttribute('config'), { childNodes } = Parser.parse(from, this.getAttribute('include'), undefined, config);
+        if (!unidirectional) {
+            super.insertAt(debug_1.Shadow.run(() => new atom_1.AtomToken(undefined, 'converter-rule-from', config)), 0);
+        }
+        this.firstChild.replaceChildren(...childNodes);
+    }
+    /**
+     * 修改为单向转换
+     * @param from 转换原文
+     */
+    makeUnidirectional(from) {
+        this.setFrom(from);
+    }
+    /** 修改为双向转换 */
+    makeBidirectional() {
+        if (this.unidirectional) {
+            this.removeAt(0);
+        }
+    }
+}
+exports.ConverterRuleToken = ConverterRuleToken;
+constants_1.classes['ConverterRuleToken'] = __filename;

package/dist/src/extLink.d.ts

@@ -0,0 +1,53 @@
+import * as Parser from '../index';
+import { Token } from './index';
+import { MagicLinkToken } from './magicLink';
+declare const ExtLinkToken_base: (abstract new (...args: any[]) => {
+    readonly firstChild: Parser.MagicLinkToken;
+    readonly firstElementChild: Parser.MagicLinkToken;
+    protocol: string | undefined;
+    link: string;
+    getUrl(): URL;
+    setTarget(url: string): void;
+    readonly length: number;
+    toString(omit?: Set<string> | undefined, separator?: string | undefined): string;
+    text(separator?: string | undefined): string;
+    insertAt(token: unknown, i?: number | undefined): unknown;
+    afterBuild(): void;
+    getAttribute<T extends string>(key: T): TokenAttributeGetter<T>;
+    setAttribute<T_1 extends string>(key: T_1, value: TokenAttributeSetter<T_1>): void;
+    addEventListener(events: string | string[], listener: AstListener): void;
+    replaceChildren(...elements: (string | Parser.AstNodes)[]): void;
+}) & typeof Parser.Token;
+/**
+ * 外链
+ * @classdesc `{childNodes: [MagicLinkToken, ?Token]}`
+ */
+export declare class ExtLinkToken extends ExtLinkToken_base {
+    #private;
+    readonly type = "ext-link";
+    readonly childNodes: [MagicLinkToken] | [MagicLinkToken, Token];
+    abstract get children(): [MagicLinkToken] | [MagicLinkToken, Token];
+    abstract get lastChild(): Token;
+    abstract get lastElementChild(): Token;
+    /** 链接显示文字 */
+    get innerText(): string;
+    set innerText(text: string);
+    /**
+     * @param url 网址
+     * @param space 空白字符
+     * @param text 链接文字
+     */
+    constructor(url?: string, space?: string, text?: string, config?: Parser.Config, accum?: Token[]);
+    /** @override */
+    text(): string;
+    /** @override */
+    print(): string;
+    /** @override */
+    cloneNode(): this;
+    /**
+     * 设置链接显示文字
+     * @param str 链接显示文字
+     */
+    setLinkText(str: string): void;
+}
+export {};

package/dist/src/extLink.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtLinkToken = void 0;
+const string_1 = require("../util/string");
+const debug_1 = require("../util/debug");
+const constants_1 = require("../util/constants");
+const magicLinkParent_1 = require("../mixin/magicLinkParent");
+const Parser = require("../index");
+const index_1 = require("./index");
+const magicLink_1 = require("./magicLink");
+/**
+ * 外链
+ * @classdesc `{childNodes: [MagicLinkToken, ?Token]}`
+ */
+class ExtLinkToken extends (0, magicLinkParent_1.magicLinkParent)(index_1.Token) {
+    type = 'ext-link';
+    #space;
+    /* NOT FOR BROWSER */
+    /** 链接显示文字 */
+    get innerText() {
+        return this.length > 1
+            ? this.lastChild.text()
+            : `[${this.getRootNode().querySelectorAll('ext-link[childElementCount=1]').indexOf(this) + 1}]`;
+    }
+    set innerText(text) {
+        this.setLinkText(text);
+    }
+    /* NOT FOR BROWSER END */
+    /**
+     * @param url 网址
+     * @param space 空白字符
+     * @param text 链接文字
+     */
+    constructor(url, space = '', text = '', config = Parser.getConfig(), accum = []) {
+        super(undefined, config, accum, {
+            MagicLinkToken: 0, Token: 1,
+        });
+        this.insertAt(new magicLink_1.MagicLinkToken(url, true, config, accum));
+        this.#space = space;
+        if (text) {
+            const inner = new index_1.Token(text, config, accum, {
+                'Stage-7': ':', ConverterToken: ':',
+            });
+            inner.type = 'ext-link-text';
+            inner.setAttribute('stage', constants_1.MAX_STAGE - 1);
+            this.insertAt(inner);
+        }
+        this.protectChildren(0);
+    }
+    /** @private */
+    toString(omit) {
+        if (omit && this.matchesTypes(omit)) {
+            return '';
+        }
+        if (this.length === 1) {
+            return `[${super.toString(omit)}${this.#space}]`;
+        }
+        this.#correct();
+        (0, string_1.normalizeSpace)(this.lastChild);
+        return `[${super.toString(omit, this.#space)}]`;
+    }
+    /** @override */
+    text() {
+        (0, string_1.normalizeSpace)(this.childNodes[1]);
+        return `[${super.text(' ')}]`;
+    }
+    /** @private */
+    getAttribute(key) {
+        return key === 'padding' ? 1 : super.getAttribute(key);
+    }
+    /** @private */
+    getGaps() {
+        this.#correct();
+        return this.#space.length;
+    }
+    /** @override */
+    print() {
+        return super.print(this.length === 1 ? { pre: '[', post: `${this.#space}]` } : { pre: '[', sep: this.#space, post: ']' });
+    }
+    /* NOT FOR BROWSER */
+    /** @override */
+    cloneNode() {
+        const [url, text] = this.cloneChildNodes();
+        return debug_1.Shadow.run(() => {
+            const token = new ExtLinkToken(undefined, '', '', this.getAttribute('config'));
+            token.firstChild.safeReplaceWith(url);
+            if (text) {
+                token.insertAt(text);
+            }
+            return token;
+        });
+    }
+    /** 修正空白字符 */
+    #correct() {
+        if (!this.#space && this.length > 1
+            // 都替换成`<`肯定不对，但无妨
+            && /^[^[\]<>"{\0-\x1F\x7F\p{Zs}\uFFFD]/u.test(this.lastChild.text().replace(/&[lg]t;/u, '<'))) {
+            this.#space = ' ';
+        }
+    }
+    /**
+     * 设置链接显示文字
+     * @param str 链接显示文字
+     */
+    setLinkText(str) {
+        const root = Parser.parse(str, this.getAttribute('include'), 7, this.getAttribute('config'));
+        if (this.length === 1) {
+            root.type = 'ext-link-text';
+            root.setAttribute('acceptable', {
+                'Stage-7': ':', ConverterToken: ':',
+            });
+            this.insertAt(root);
+        }
+        else {
+            this.lastChild.replaceChildren(...root.childNodes);
+        }
+        this.#space ||= ' ';
+    }
+}
+exports.ExtLinkToken = ExtLinkToken;
+constants_1.classes['ExtLinkToken'] = __filename;