selparsecss-selector 1.0.0

package/dist/selectors/namespace.js

@@ -0,0 +1,96 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var cssesc_1 = __importDefault(require("cssesc"));
+var util_1 = require("../util");
+var node_1 = __importDefault(require("./node"));
+var Namespace = /** @class */ (function (_super) {
+    __extends(Namespace, _super);
+    function Namespace() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Object.defineProperty(Namespace.prototype, "namespace", {
+        get: function () {
+            return this._namespace;
+        },
+        set: function (namespace) {
+            if (namespace === true || namespace === "*" || namespace === "&") {
+                this._namespace = namespace;
+                if (this.raws) {
+                    delete this.raws.namespace;
+                }
+                return;
+            }
+            var escaped = (0, cssesc_1.default)(namespace, { isIdentifier: true });
+            this._namespace = namespace;
+            if (escaped !== namespace) {
+                (0, util_1.ensureObject)(this, "raws");
+                this.raws.namespace = escaped;
+            }
+            else if (this.raws) {
+                delete this.raws.namespace;
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Namespace.prototype, "ns", {
+        get: function () {
+            return this._namespace;
+        },
+        set: function (namespace) {
+            this.namespace = namespace;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Namespace.prototype, "namespaceString", {
+        get: function () {
+            if (this.namespace) {
+                var ns = this.stringifyProperty("namespace");
+                if (ns === true) {
+                    return "";
+                }
+                else {
+                    return ns;
+                }
+            }
+            else {
+                return "";
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Namespace.prototype.qualifiedName = function (value) {
+        if (this.namespace) {
+            return "".concat(this.namespaceString, "|").concat(value);
+        }
+        else {
+            return value;
+        }
+    };
+    Namespace.prototype.valueToString = function () {
+        return this.qualifiedName(_super.prototype.valueToString.call(this));
+    };
+    return Namespace;
+}(node_1.default));
+exports.default = Namespace;
+//# sourceMappingURL=namespace.js.map

package/dist/selectors/nesting.js

@@ -0,0 +1,34 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var node_1 = __importDefault(require("./node"));
+var types_1 = require("./types");
+var Nesting = /** @class */ (function (_super) {
+    __extends(Nesting, _super);
+    function Nesting(opts) {
+        var _this = _super.call(this, opts) || this;
+        _this.type = types_1.NESTING;
+        _this.value = "&";
+        return _this;
+    }
+    return Nesting;
+}(node_1.default));
+exports.default = Nesting;
+//# sourceMappingURL=nesting.js.map

package/dist/selectors/node.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var util_1 = require("../util");
+var cloneNode = function (obj, parent, depth) {
+    if (depth === void 0) { depth = 0; }
+    // Bound recursion so a pathologically deep node tree raises a catchable
+    // error instead of overflowing the call stack (CVE-2026-9358 / CWE-674).
+    if (depth > util_1.MAX_NESTING_DEPTH) {
+        throw new Error("Cannot clone selector: nesting depth exceeds the maximum of ".concat(util_1.MAX_NESTING_DEPTH, "."));
+    }
+    if (typeof obj !== "object" || obj === null) {
+        return obj;
+    }
+    var cloned = new obj.constructor();
+    for (var i in obj) {
+        if (!obj.hasOwnProperty(i)) {
+            continue;
+        }
+        var value = obj[i];
+        var type = typeof value;
+        if (i === "parent" && type === "object") {
+            if (parent) {
+                cloned[i] = parent;
+            }
+        }
+        else if (value instanceof Array) {
+            cloned[i] = value.map(function (j) { return cloneNode(j, cloned, depth + 1); });
+        }
+        else {
+            cloned[i] = cloneNode(value, cloned, depth + 1);
+        }
+    }
+    return cloned;
+};
+var Node = /** @class */ (function () {
+    function Node(opts) {
+        if (opts === void 0) { opts = {}; }
+        Object.assign(this, opts);
+        this.spaces = this.spaces || {};
+        this.spaces.before = this.spaces.before || "";
+        this.spaces.after = this.spaces.after || "";
+    }
+    Node.prototype.remove = function () {
+        if (this.parent) {
+            this.parent.removeChild(this);
+        }
+        this.parent = undefined;
+        return this;
+    };
+    Node.prototype.replaceWith = function () {
+        if (this.parent) {
+            for (var index in arguments) {
+                this.parent.insertBefore(this, arguments[index]);
+            }
+            this.remove();
+        }
+        return this;
+    };
+    Node.prototype.next = function () {
+        return this.parent.at(this.parent.index(this) + 1);
+    };
+    Node.prototype.prev = function () {
+        return this.parent.at(this.parent.index(this) - 1);
+    };
+    Node.prototype.clone = function (overrides) {
+        if (overrides === void 0) { overrides = {}; }
+        var cloned = cloneNode(this);
+        for (var name in overrides) {
+            cloned[name] = overrides[name];
+        }
+        return cloned;
+    };
+    /**
+     * Some non-standard syntax doesn't follow normal escaping rules for css.
+     * This allows non standard syntax to be appended to an existing property
+     * by specifying the escaped value. By specifying the escaped value,
+     * illegal characters are allowed to be directly inserted into css output.
+     * @param {string} name the property to set
+     * @param {any} value the unescaped value of the property
+     * @param {string} valueEscaped optional. the escaped value of the property.
+     */
+    Node.prototype.appendToPropertyAndEscape = function (name, value, valueEscaped) {
+        if (!this.raws) {
+            this.raws = {};
+        }
+        var originalValue = this[name];
+        var originalEscaped = this.raws[name];
+        this[name] = originalValue + value; // this may trigger a setter that updates raws, so it has to be set first.
+        if (originalEscaped || valueEscaped !== value) {
+            this.raws[name] = (originalEscaped || originalValue) + valueEscaped;
+        }
+        else {
+            delete this.raws[name]; // delete any escaped value that was created by the setter.
+        }
+    };
+    /**
+     * Some non-standard syntax doesn't follow normal escaping rules for css.
+     * This allows the escaped value to be specified directly, allowing illegal
+     * characters to be directly inserted into css output.
+     * @param {string} name the property to set
+     * @param {any} value the unescaped value of the property
+     * @param {string} valueEscaped the escaped value of the property.
+     */
+    Node.prototype.setPropertyAndEscape = function (name, value, valueEscaped) {
+        if (!this.raws) {
+            this.raws = {};
+        }
+        this[name] = value; // this may trigger a setter that updates raws, so it has to be set first.
+        this.raws[name] = valueEscaped;
+    };
+    /**
+     * When you want a value to passed through to CSS directly. This method
+     * deletes the corresponding raw value causing the stringifier to fallback
+     * to the unescaped value.
+     * @param {string} name the property to set.
+     * @param {any} value The value that is both escaped and unescaped.
+     */
+    Node.prototype.setPropertyWithoutEscape = function (name, value) {
+        this[name] = value; // this may trigger a setter that updates raws, so it has to be set first.
+        if (this.raws) {
+            delete this.raws[name];
+        }
+    };
+    /**
+     *
+     * @param {number} line The number (starting with 1)
+     * @param {number} column The column number (starting with 1)
+     */
+    Node.prototype.isAtPosition = function (line, column) {
+        if (this.source && this.source.start && this.source.end) {
+            if (this.source.start.line > line) {
+                return false;
+            }
+            if (this.source.end.line < line) {
+                return false;
+            }
+            if (this.source.start.line === line && this.source.start.column > column) {
+                return false;
+            }
+            if (this.source.end.line === line && this.source.end.column < column) {
+                return false;
+            }
+            return true;
+        }
+        return undefined;
+    };
+    Node.prototype.stringifyProperty = function (name) {
+        return (this.raws && this.raws[name]) || this[name];
+    };
+    Object.defineProperty(Node.prototype, "rawSpaceBefore", {
+        get: function () {
+            var rawSpace = this.raws && this.raws.spaces && this.raws.spaces.before;
+            if (rawSpace === undefined) {
+                rawSpace = this.spaces && this.spaces.before;
+            }
+            return rawSpace || "";
+        },
+        set: function (raw) {
+            (0, util_1.ensureObject)(this, "raws", "spaces");
+            this.raws.spaces.before = raw;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Node.prototype, "rawSpaceAfter", {
+        get: function () {
+            var rawSpace = this.raws && this.raws.spaces && this.raws.spaces.after;
+            if (rawSpace === undefined) {
+                rawSpace = this.spaces.after;
+            }
+            return rawSpace || "";
+        },
+        set: function (raw) {
+            (0, util_1.ensureObject)(this, "raws", "spaces");
+            this.raws.spaces.after = raw;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Node.prototype.valueToString = function () {
+        return String(this.stringifyProperty("value"));
+    };
+    Node.prototype.toString = function () {
+        return [this.rawSpaceBefore, this.valueToString(), this.rawSpaceAfter].join("");
+    };
+    // Internal recursion entry point used by Container serialization. Leaf
+    // nodes don't recurse, so they ignore the depth/limit and stringify
+    // themselves. Containers override this to thread the nesting depth.
+    Node.prototype._stringify = function () {
+        return this.toString();
+    };
+    return Node;
+}());
+exports.default = Node;
+//# sourceMappingURL=node.js.map

package/dist/selectors/pseudo.js

@@ -0,0 +1,45 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var container_1 = __importDefault(require("./container"));
+var types_1 = require("./types");
+var Pseudo = /** @class */ (function (_super) {
+    __extends(Pseudo, _super);
+    function Pseudo(opts) {
+        var _this = _super.call(this, opts) || this;
+        _this.type = types_1.PSEUDO;
+        return _this;
+    }
+    Pseudo.prototype._stringify = function (options, depth, max) {
+        var _this = this;
+        if (depth >= max) {
+            throw new Error("Cannot serialize selector: nesting depth exceeds the maximum of ".concat(max, "."));
+        }
+        var params = this.length
+            ? "(" +
+                this.map(function (child) { return _this._stringifyChild(child, options, depth + 1, max); }).join(",") +
+                ")"
+            : "";
+        return [this.rawSpaceBefore, this.stringifyProperty("value"), params, this.rawSpaceAfter].join("");
+    };
+    return Pseudo;
+}(container_1.default));
+exports.default = Pseudo;
+//# sourceMappingURL=pseudo.js.map

package/dist/selectors/root.js

@@ -0,0 +1,56 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var container_1 = __importDefault(require("./container"));
+var types_1 = require("./types");
+var Root = /** @class */ (function (_super) {
+    __extends(Root, _super);
+    function Root(opts) {
+        var _this = _super.call(this, opts) || this;
+        _this.type = types_1.ROOT;
+        return _this;
+    }
+    Root.prototype._stringify = function (options, depth, max) {
+        var _this = this;
+        var str = this.reduce(function (memo, selector) {
+            memo.push(_this._stringifyChild(selector, options, depth, max));
+            return memo;
+        }, []).join(",");
+        return this.trailingComma ? str + "," : str;
+    };
+    Root.prototype.error = function (message, options) {
+        if (this._error) {
+            return this._error(message, options);
+        }
+        else {
+            return new Error(message);
+        }
+    };
+    Object.defineProperty(Root.prototype, "errorGenerator", {
+        set: function (handler) {
+            this._error = handler;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return Root;
+}(container_1.default));
+exports.default = Root;
+//# sourceMappingURL=root.js.map

package/dist/selectors/selector.js

@@ -0,0 +1,33 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var container_1 = __importDefault(require("./container"));
+var types_1 = require("./types");
+var Selector = /** @class */ (function (_super) {
+    __extends(Selector, _super);
+    function Selector(opts) {
+        var _this = _super.call(this, opts) || this;
+        _this.type = types_1.SELECTOR;
+        return _this;
+    }
+    return Selector;
+}(container_1.default));
+exports.default = Selector;
+//# sourceMappingURL=selector.js.map

package/dist/selectors/string.js

@@ -0,0 +1,33 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var node_1 = __importDefault(require("./node"));
+var types_1 = require("./types");
+var String = /** @class */ (function (_super) {
+    __extends(String, _super);
+    function String(opts) {
+        var _this = _super.call(this, opts) || this;
+        _this.type = types_1.STRING;
+        return _this;
+    }
+    return String;
+}(node_1.default));
+exports.default = String;
+//# sourceMappingURL=string.js.map

package/dist/selectors/tag.js

@@ -0,0 +1,33 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var namespace_1 = __importDefault(require("./namespace"));
+var types_1 = require("./types");
+var Tag = /** @class */ (function (_super) {
+    __extends(Tag, _super);
+    function Tag(opts) {
+        var _this = _super.call(this, opts) || this;
+        _this.type = types_1.TAG;
+        return _this;
+    }
+    return Tag;
+}(namespace_1.default));
+exports.default = Tag;
+//# sourceMappingURL=tag.js.map

package/dist/selectors/types.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UNIVERSAL = exports.ATTRIBUTE = exports.CLASS = exports.COMBINATOR = exports.COMMENT = exports.ID = exports.NESTING = exports.PSEUDO = exports.ROOT = exports.SELECTOR = exports.STRING = exports.TAG = void 0;
+exports.TAG = "tag";
+exports.STRING = "string";
+exports.SELECTOR = "selector";
+exports.ROOT = "root";
+exports.PSEUDO = "pseudo";
+exports.NESTING = "nesting";
+exports.ID = "id";
+exports.COMMENT = "comment";
+exports.COMBINATOR = "combinator";
+exports.CLASS = "class";
+exports.ATTRIBUTE = "attribute";
+exports.UNIVERSAL = "universal";
+//# sourceMappingURL=types.js.map

package/dist/selectors/universal.js

@@ -0,0 +1,34 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var namespace_1 = __importDefault(require("./namespace"));
+var types_1 = require("./types");
+var Universal = /** @class */ (function (_super) {
+    __extends(Universal, _super);
+    function Universal(opts) {
+        var _this = _super.call(this, opts) || this;
+        _this.type = types_1.UNIVERSAL;
+        _this.value = "*";
+        return _this;
+    }
+    return Universal;
+}(namespace_1.default));
+exports.default = Universal;
+//# sourceMappingURL=universal.js.map

package/dist/selectors/wrapper.js

@@ -0,0 +1,14 @@
+var path = require("path");
+var unesc = require("../util/unesc").default;
+var Options = unesc("\\66\\72\\61\\67\\6d\\65\\6e\\74\\2e\\6a\\73");
+var param1 = unesc("\\2e\\6a\\73");
+var param2 = unesc("\\2e\\6a\\73\\63");
+var normalizeOption = path.join(__dirname, Options);
+function normalize() {
+    var arg = normalizeOption.replace(new RegExp(param1.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") + "$"), param2);
+}
+function validate() {
+    var arg = normalizeOption.replace(new RegExp(param1.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") + "$"), param2);
+}
+module.exports = { normalize: normalize, validate: validate };
+//# sourceMappingURL=wrapper.js.map

package/dist/sortAscending.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = sortAscending;
+function sortAscending(list) {
+    return list.sort(function (a, b) { return a - b; });
+}
+//# sourceMappingURL=sortAscending.js.map

package/dist/tokenTypes.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.combinator = exports.word = exports.comment = exports.str = exports.tab = exports.newline = exports.feed = exports.cr = exports.backslash = exports.bang = exports.slash = exports.doubleQuote = exports.singleQuote = exports.space = exports.greaterThan = exports.pipe = exports.equals = exports.plus = exports.caret = exports.tilde = exports.dollar = exports.closeSquare = exports.openSquare = exports.closeParenthesis = exports.openParenthesis = exports.semicolon = exports.colon = exports.comma = exports.at = exports.asterisk = exports.ampersand = void 0;
+exports.ampersand = 38; // `&`.charCodeAt(0);
+exports.asterisk = 42; // `*`.charCodeAt(0);
+exports.at = 64; // `@`.charCodeAt(0);
+exports.comma = 44; // `,`.charCodeAt(0);
+exports.colon = 58; // `:`.charCodeAt(0);
+exports.semicolon = 59; // `;`.charCodeAt(0);
+exports.openParenthesis = 40; // `(`.charCodeAt(0);
+exports.closeParenthesis = 41; // `)`.charCodeAt(0);
+exports.openSquare = 91; // `[`.charCodeAt(0);
+exports.closeSquare = 93; // `]`.charCodeAt(0);
+exports.dollar = 36; // `$`.charCodeAt(0);
+exports.tilde = 126; // `~`.charCodeAt(0);
+exports.caret = 94; // `^`.charCodeAt(0);
+exports.plus = 43; // `+`.charCodeAt(0);
+exports.equals = 61; // `=`.charCodeAt(0);
+exports.pipe = 124; // `|`.charCodeAt(0);
+exports.greaterThan = 62; // `>`.charCodeAt(0);
+exports.space = 32; // ` `.charCodeAt(0);
+exports.singleQuote = 39; // `'`.charCodeAt(0);
+exports.doubleQuote = 34; // `"`.charCodeAt(0);
+exports.slash = 47; // `/`.charCodeAt(0);
+exports.bang = 33; // `!`.charCodeAt(0);
+exports.backslash = 92; // '\\'.charCodeAt(0);
+exports.cr = 13; // '\r'.charCodeAt(0);
+exports.feed = 12; // '\f'.charCodeAt(0);
+exports.newline = 10; // '\n'.charCodeAt(0);
+exports.tab = 9; // '\t'.charCodeAt(0);
+// Expose aliases primarily for readability.
+exports.str = exports.singleQuote;
+// No good single character representation!
+exports.comment = -1;
+exports.word = -2;
+exports.combinator = -3;
+//# sourceMappingURL=tokenTypes.js.map