toolcraft 0.0.117 → 0.0.118

package/composition.json

@@ -66,11 +66,6 @@
       "version": "3.3.1",
       "license": "MIT"
     },
-    {
-      "name": "pct-encode",
-      "version": "1.0.3",
-      "license": "BSD-2-Clause"
-    },
     {
       "name": "sisteransi",
       "version": "1.0.5",
@@ -93,7 +88,7 @@
     },
     {
       "name": "toolcraft",
-      "version": "0.0.117",
+      "version": "0.0.118",
       "license": "MIT"
     },
     {
@@ -103,17 +98,7 @@
     },
     {
       "name": "toolcraft-schema",
-      "version": "0.0.117",
-      "license": "MIT"
-    },
-    {
-      "name": "uri-template",
-      "version": "2.0.0",
-      "license": "MIT"
-    },
-    {
-      "name": "uri-template-lite",
-      "version": "23.4.0",
+      "version": "0.0.118",
       "license": "MIT"
     },
     {

package/dist/composition.json

@@ -66,11 +66,6 @@
       "version": "3.3.1",
       "license": "MIT"
     },
-    {
-      "name": "pct-encode",
-      "version": "1.0.3",
-      "license": "BSD-2-Clause"
-    },
     {
       "name": "sisteransi",
       "version": "1.0.5",
@@ -93,7 +88,7 @@
     },
     {
       "name": "toolcraft",
-      "version": "0.0.117",
+      "version": "0.0.118",
       "license": "MIT"
     },
     {
@@ -103,17 +98,7 @@
     },
     {
       "name": "toolcraft-schema",
-      "version": "0.0.117",
-      "license": "MIT"
-    },
-    {
-      "name": "uri-template",
-      "version": "2.0.0",
-      "license": "MIT"
-    },
-    {
-      "name": "uri-template-lite",
-      "version": "23.4.0",
+      "version": "0.0.118",
       "license": "MIT"
     },
     {

package/node_modules/tiny-stdio-mcp-server/dist/composition.json

@@ -8,7 +8,7 @@
     },
     {
       "name": "toolcraft-schema",
-      "version": "0.0.117",
+      "version": "0.0.118",
       "license": "MIT"
     }
   ]

package/node_modules/tiny-stdio-mcp-server/dist/server.js

@@ -1,9 +1,8 @@
 import * as readline from "readline";
 import { compileJsonSchema, formatIssues } from "toolcraft-schema";
-import uriTemplateParser from "uri-template";
-import UriTemplate from "uri-template-lite";
 import { JSON_RPC_ERROR_CODES, ToolError } from "./types.js";
 import { parseMessage, formatSuccessResponse, formatErrorResponse } from "./jsonrpc.js";
+import { parseUriTemplate } from "./uri-template.js";
 import { toContentBlocks } from "./content/convert.js";
 const PROTOCOL_VERSION = "2025-11-25";
 const SUPPORTED_PROTOCOL_VERSIONS = new Set(["2025-03-26", "2025-06-18", PROTOCOL_VERSION]);
@@ -228,7 +227,7 @@ export function createServer(options) {
         if (method === "resources/templates/list") {
             return {
                 result: {
-                    resourceTemplates: [...resourceTemplates.values()].map(({ handler: _handler, ...resourceTemplate }) => resourceTemplate)
+                    resourceTemplates: [...resourceTemplates.values()].map(({ handler: _handler, template: _template, ...resourceTemplate }) => resourceTemplate)
                 }
             };
         }
@@ -451,12 +450,11 @@ export function createServer(options) {
             return server;
         },
         resourceTemplate(definition, handler) {
-            assertReadableUriTemplate(definition.uriTemplate);
-            new UriTemplate(definition.uriTemplate);
+            const template = parseReadableUriTemplate(definition.uriTemplate);
             if (resourceTemplates.has(definition.uriTemplate)) {
                 throw new Error(`Resource template already registered: ${definition.uriTemplate}`);
             }
-            resourceTemplates.set(definition.uriTemplate, { ...definition, handler });
+            resourceTemplates.set(definition.uriTemplate, { ...definition, handler, template });
             return server;
         },
         method(name, handler) {
@@ -660,14 +658,12 @@ function assertNonEmptyName(name, message) {
         throw new Error(message);
     }
 }
-function assertReadableUriTemplate(uriTemplate) {
-    const parsed = uriTemplateParser.parse(uriTemplate);
-    const expanded = parsed.expand(new Proxy({}, {
-        get: (_target, property) => (typeof property === "string" ? "value" : undefined)
-    }));
-    if (typeof expanded !== "string" || !isValidUri(expanded)) {
+function parseReadableUriTemplate(uriTemplate) {
+    const template = parseUriTemplate(uriTemplate);
+    if (!isValidUri(template.expand({}))) {
         throw new Error(`Invalid resource URI template: ${uriTemplate}`);
     }
+    return template;
 }
 function toStringArguments(value) {
     if (value === undefined) {
@@ -693,15 +689,7 @@ function findReadableResource(uri, resources, resourceTemplates) {
     if (resource !== undefined) {
         return resource;
     }
-    return [...resourceTemplates.values()].find((template) => matchesUriTemplate(template.uriTemplate, uri));
-}
-function matchesUriTemplate(template, uri) {
-    try {
-        return new UriTemplate(template).match(uri) !== null;
-    }
-    catch {
-        return false;
-    }
+    return [...resourceTemplates.values()].find((template) => template.template.match(uri) !== null);
 }
 function isCallToolResult(value) {
     if (!hasContentArray(value) || !value.content.every(isContentItem)) {

package/node_modules/tiny-stdio-mcp-server/dist/uri-template.d.ts

@@ -0,0 +1,6 @@
+export type UriTemplateValue = string | string[] | Record<string, string>;
+export interface UriTemplate {
+    expand(variables: Record<string, UriTemplateValue>): string;
+    match(uri: string): Record<string, string> | null;
+}
+export declare function parseUriTemplate(template: string): UriTemplate;

package/node_modules/tiny-stdio-mcp-server/dist/uri-template.js

@@ -0,0 +1,363 @@
+const operatorOptions = {
+    "": { prefix: "", separator: ",", named: false, ifEmpty: "", allowReserved: false },
+    "+": { prefix: "", separator: ",", named: false, ifEmpty: "", allowReserved: true },
+    "#": { prefix: "#", separator: ",", named: false, ifEmpty: "", allowReserved: true },
+    ".": { prefix: ".", separator: ".", named: false, ifEmpty: "", allowReserved: false },
+    "/": { prefix: "/", separator: "/", named: false, ifEmpty: "", allowReserved: false },
+    ";": { prefix: ";", separator: ";", named: true, ifEmpty: "", allowReserved: false },
+    "?": { prefix: "?", separator: "&", named: true, ifEmpty: "=", allowReserved: false },
+    "&": { prefix: "&", separator: "&", named: true, ifEmpty: "=", allowReserved: false }
+};
+const operators = new Set(["", "+", "#", ".", "/", ";", "?", "&"]);
+const reservedCharacters = new Set(":/?#[]@!$&'()*+,;=".split(""));
+class ParsedUriTemplate {
+    segments;
+    constructor(segments) {
+        this.segments = segments;
+    }
+    expand(variables) {
+        return this.segments
+            .map((segment) => segment.kind === "literal" ? segment.value : expandExpression(segment, variables))
+            .join("");
+    }
+    match(uri) {
+        return matchSegments(this.segments, uri, 0, 0, {});
+    }
+}
+export function parseUriTemplate(template) {
+    if (typeof template !== "string") {
+        throw new Error("URI template must be a string.");
+    }
+    const segments = [];
+    let literalStart = 0;
+    let index = 0;
+    while (index < template.length) {
+        const character = template[index];
+        if (character === "}") {
+            throw syntaxError(template, index, "unmatched closing brace");
+        }
+        if (character !== "{") {
+            index += 1;
+            continue;
+        }
+        if (index > literalStart) {
+            segments.push({ kind: "literal", value: template.slice(literalStart, index) });
+        }
+        const closeIndex = template.indexOf("}", index + 1);
+        if (closeIndex === -1) {
+            throw syntaxError(template, index, "unclosed expression");
+        }
+        const expression = template.slice(index + 1, closeIndex);
+        if (expression.includes("{")) {
+            throw syntaxError(template, index, "nested expression");
+        }
+        segments.push(parseExpression(template, expression, index));
+        index = closeIndex + 1;
+        literalStart = index;
+    }
+    if (literalStart < template.length) {
+        segments.push({ kind: "literal", value: template.slice(literalStart) });
+    }
+    if (segments.length === 0) {
+        segments.push({ kind: "literal", value: "" });
+    }
+    return new ParsedUriTemplate(segments);
+}
+function parseExpression(template, expression, offset) {
+    if (expression.length === 0) {
+        throw syntaxError(template, offset, "empty expression");
+    }
+    const first = expression[0];
+    const operator = operators.has(first) && first !== "" ? first : "";
+    const variableList = operator === "" ? expression : expression.slice(1);
+    if (variableList.length === 0) {
+        throw syntaxError(template, offset, "expression has no variables");
+    }
+    if (operator === "" && isReservedOperatorCharacter(first)) {
+        throw syntaxError(template, offset, `unsupported operator ${first}`);
+    }
+    const variables = variableList
+        .split(",")
+        .map((variable) => parseVariableSpec(template, variable, offset));
+    return { kind: "expression", operator, variables };
+}
+function parseVariableSpec(template, source, offset) {
+    if (source.length === 0) {
+        throw syntaxError(template, offset, "empty variable specification");
+    }
+    const explode = source.endsWith("*");
+    const withoutExplode = explode ? source.slice(0, -1) : source;
+    const colonIndex = withoutExplode.indexOf(":");
+    if (explode && colonIndex !== -1) {
+        throw syntaxError(template, offset, "explode and prefix modifiers cannot be combined");
+    }
+    const name = colonIndex === -1 ? withoutExplode : withoutExplode.slice(0, colonIndex);
+    if (!isValidVariableName(name)) {
+        throw syntaxError(template, offset, `invalid variable name ${name}`);
+    }
+    if (colonIndex === -1) {
+        return { name, explode };
+    }
+    const prefixSource = withoutExplode.slice(colonIndex + 1);
+    if (!isValidPrefix(prefixSource)) {
+        throw syntaxError(template, offset, `invalid prefix modifier ${prefixSource}`);
+    }
+    return { name, explode: false, prefixLength: Number(prefixSource) };
+}
+function isValidVariableName(name) {
+    if (name.length === 0) {
+        return false;
+    }
+    let componentLength = 0;
+    for (let index = 0; index < name.length; index += 1) {
+        const character = name[index];
+        if (character === ".") {
+            if (componentLength === 0)
+                return false;
+            componentLength = 0;
+            continue;
+        }
+        if (character === "%") {
+            if (!isHex(name[index + 1]) || !isHex(name[index + 2]))
+                return false;
+            index += 2;
+            componentLength += 1;
+            continue;
+        }
+        if (!isVariableCharacter(character))
+            return false;
+        componentLength += 1;
+    }
+    return componentLength > 0;
+}
+function isValidPrefix(value) {
+    if (value.length === 0 || value.length > 4 || value[0] === "0") {
+        return false;
+    }
+    return [...value].every((character) => character >= "0" && character <= "9");
+}
+function isReservedOperatorCharacter(character) {
+    return "=,!@|".includes(character);
+}
+function isVariableCharacter(character) {
+    return ((character >= "a" && character <= "z") ||
+        (character >= "A" && character <= "Z") ||
+        (character >= "0" && character <= "9") ||
+        character === "_");
+}
+function isHex(character) {
+    return (character !== undefined &&
+        ((character >= "0" && character <= "9") ||
+            (character >= "a" && character <= "f") ||
+            (character >= "A" && character <= "F")));
+}
+function syntaxError(template, index, detail) {
+    return new Error(`Invalid URI template at ${index}: ${detail} (${template})`);
+}
+function expandExpression(expression, variables) {
+    const options = operatorOptions[expression.operator];
+    const parts = [];
+    for (const variable of expression.variables) {
+        const value = variables[variable.name];
+        if (value === undefined || value === null) {
+            continue;
+        }
+        parts.push(...expandVariable(variable, value, options));
+    }
+    return parts.length === 0 ? "" : `${options.prefix}${parts.join(options.separator)}`;
+}
+function expandVariable(variable, value, options) {
+    if (Array.isArray(value)) {
+        if (variable.prefixLength !== undefined) {
+            throw new Error(`Prefix modifier requires a scalar value: ${variable.name}`);
+        }
+        return expandList(variable, value, options);
+    }
+    if (isRecord(value)) {
+        if (variable.prefixLength !== undefined) {
+            throw new Error(`Prefix modifier requires a scalar value: ${variable.name}`);
+        }
+        return expandAssociative(variable, value, options);
+    }
+    const original = String(value);
+    const scalar = variable.prefixLength === undefined
+        ? original
+        : [...original].slice(0, variable.prefixLength).join("");
+    const encoded = encodeValue(scalar, options.allowReserved);
+    return [namedValue(variable.name, encoded, options)];
+}
+function expandList(variable, value, options) {
+    if (value.length === 0) {
+        return [];
+    }
+    const encoded = value.map((item) => encodeValue(String(item), options.allowReserved));
+    if (!variable.explode) {
+        return [namedValue(variable.name, encoded.join(","), options)];
+    }
+    if (!options.named) {
+        return encoded;
+    }
+    return encoded.map((item) => namedValue(variable.name, item, options));
+}
+function expandAssociative(variable, value, options) {
+    const entries = Object.entries(value);
+    if (entries.length === 0) {
+        return [];
+    }
+    const encoded = entries.map(([key, item]) => [
+        encodeValue(key, options.allowReserved),
+        encodeValue(String(item), options.allowReserved)
+    ]);
+    if (!variable.explode) {
+        return [namedValue(variable.name, encoded.flat().join(","), options)];
+    }
+    return encoded.map(([key, item]) => `${key}=${item}`);
+}
+function namedValue(name, value, options) {
+    if (!options.named) {
+        return value;
+    }
+    const encodedName = encodeValue(name, true);
+    if (value.length === 0) {
+        return `${encodedName}${options.ifEmpty}`;
+    }
+    return `${encodedName}=${value}`;
+}
+function encodeValue(value, allowReserved) {
+    let result = "";
+    for (let index = 0; index < value.length; index += 1) {
+        const character = value[index];
+        if (allowReserved && character === "%" && isHex(value[index + 1]) && isHex(value[index + 2])) {
+            result += value.slice(index, index + 3);
+            index += 2;
+            continue;
+        }
+        const codePoint = value.codePointAt(index);
+        if (codePoint === undefined)
+            continue;
+        const scalar = String.fromCodePoint(codePoint);
+        if (scalar.length === 2)
+            index += 1;
+        if (isUnreserved(scalar) || (allowReserved && reservedCharacters.has(scalar))) {
+            result += scalar;
+            continue;
+        }
+        for (const byte of new TextEncoder().encode(scalar)) {
+            result += `%${byte.toString(16).toUpperCase().padStart(2, "0")}`;
+        }
+    }
+    return result;
+}
+function isUnreserved(character) {
+    return ((character >= "a" && character <= "z") ||
+        (character >= "A" && character <= "Z") ||
+        (character >= "0" && character <= "9") ||
+        "-._~".includes(character));
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function matchSegments(segments, uri, segmentIndex, uriIndex, captures) {
+    if (segmentIndex === segments.length) {
+        return uriIndex === uri.length ? captures : null;
+    }
+    const segment = segments[segmentIndex];
+    if (segment.kind === "literal") {
+        return uri.startsWith(segment.value, uriIndex)
+            ? matchSegments(segments, uri, segmentIndex + 1, uriIndex + segment.value.length, captures)
+            : null;
+    }
+    for (const endIndex of candidateExpressionEnds(segments, uri, segmentIndex, uriIndex)) {
+        const expressionCaptures = matchExpression(segment, uri.slice(uriIndex, endIndex));
+        if (expressionCaptures === null)
+            continue;
+        const result = matchSegments(segments, uri, segmentIndex + 1, endIndex, {
+            ...captures,
+            ...expressionCaptures
+        });
+        if (result !== null)
+            return result;
+    }
+    return null;
+}
+function candidateExpressionEnds(segments, uri, segmentIndex, uriIndex) {
+    const next = segments[segmentIndex + 1];
+    if (next === undefined) {
+        return [uri.length];
+    }
+    const boundary = next.kind === "literal" ? next.value : operatorOptions[next.operator].prefix;
+    if (boundary.length === 0) {
+        return descendingRange(uriIndex, uri.length);
+    }
+    const indices = [];
+    let searchIndex = uri.length;
+    while (searchIndex >= uriIndex) {
+        const found = uri.lastIndexOf(boundary, searchIndex);
+        if (found < uriIndex)
+            break;
+        indices.push(found);
+        searchIndex = found - 1;
+    }
+    return indices;
+}
+function descendingRange(start, end) {
+    const values = [];
+    for (let value = end; value >= start; value -= 1)
+        values.push(value);
+    return values;
+}
+function matchExpression(expression, expansion) {
+    const options = operatorOptions[expression.operator];
+    if (expansion.length === 0) {
+        return {};
+    }
+    if (options.prefix.length > 0 && !expansion.startsWith(options.prefix)) {
+        return null;
+    }
+    const body = options.prefix.length === 0 ? expansion : expansion.slice(options.prefix.length);
+    if (options.named) {
+        return matchNamedExpression(expression.variables, body, options.separator);
+    }
+    return matchPositionalExpression(expression.variables, body, options.separator);
+}
+function matchNamedExpression(variables, body, separator) {
+    const captures = {};
+    const fields = body.length === 0 ? [] : body.split(separator);
+    for (const variable of variables) {
+        const encodedName = encodeValue(variable.name, true);
+        const values = [];
+        for (const field of fields) {
+            const equalsIndex = field.indexOf("=");
+            const key = equalsIndex === -1 ? field : field.slice(0, equalsIndex);
+            if (key === encodedName) {
+                values.push(equalsIndex === -1 ? "" : field.slice(equalsIndex + 1));
+            }
+        }
+        if (values.length > 0) {
+            captures[variable.name] = decodeValue(values.join(variable.explode ? "," : ""));
+        }
+        else if (variable.explode && variables.length === 1 && body.length > 0) {
+            captures[variable.name] = decodeValue(body);
+        }
+    }
+    return captures;
+}
+function matchPositionalExpression(variables, body, separator) {
+    if (variables.length === 1) {
+        return { [variables[0].name]: decodeValue(body) };
+    }
+    const captures = {};
+    const fields = body.split(separator);
+    for (let index = 0; index < variables.length && index < fields.length; index += 1) {
+        captures[variables[index].name] = decodeValue(index === variables.length - 1 ? fields.slice(index).join(separator) : fields[index]);
+    }
+    return captures;
+}
+function decodeValue(value) {
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        return value;
+    }
+}

package/node_modules/toolcraft-schema/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolcraft-schema",
-  "version": "0.0.117",
+  "version": "0.0.118",
   "license": "MIT",
   "type": "module",
   "main": "dist/index.js",
@@ -8,7 +8,8 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
     }
   },
   "scripts": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolcraft",
-  "version": "0.0.117",
+  "version": "0.0.118",
   "license": "MIT",
   "type": "module",
   "main": "dist/index.js",
@@ -104,8 +104,8 @@
     "test": "cd ../.. && vitest run packages/toolcraft/src",
     "test:unit": "cd ../.. && vitest run packages/toolcraft/src",
     "lint": "cd ../.. && eslint packages/toolcraft/src --ext ts && tsc -p packages/toolcraft/tsconfig.json --noEmit",
-    "prepack": "node ../../scripts/manage-bundled-workspace-deps.mjs prepare . toolcraft-schema toolcraft-design @poe-code/frontmatter @poe-code/agent-mcp-config @poe-code/agent-human-in-loop @poe-code/task-list @poe-code/agent-defs @poe-code/config-mutations @poe-code/process-runner tiny-mcp-client tiny-stdio-mcp-server auth-store fast-string-width fast-wrap-ansi ignore jsonc-parser sisteransi smol-toml uri-template uri-template-lite yaml",
-    "postpack": "node ../../scripts/manage-bundled-workspace-deps.mjs cleanup . toolcraft-schema toolcraft-design @poe-code/frontmatter @poe-code/agent-mcp-config @poe-code/agent-human-in-loop @poe-code/task-list @poe-code/agent-defs @poe-code/config-mutations @poe-code/process-runner tiny-mcp-client tiny-stdio-mcp-server auth-store fast-string-width fast-wrap-ansi ignore jsonc-parser sisteransi smol-toml uri-template uri-template-lite yaml"
+    "prepack": "node ../../scripts/manage-bundled-workspace-deps.mjs prepare . toolcraft-schema toolcraft-design @poe-code/frontmatter @poe-code/agent-mcp-config @poe-code/agent-human-in-loop @poe-code/task-list @poe-code/agent-defs @poe-code/config-mutations @poe-code/process-runner tiny-mcp-client tiny-stdio-mcp-server auth-store fast-string-width fast-wrap-ansi ignore jsonc-parser sisteransi smol-toml yaml",
+    "postpack": "node ../../scripts/manage-bundled-workspace-deps.mjs cleanup . toolcraft-schema toolcraft-design @poe-code/frontmatter @poe-code/agent-mcp-config @poe-code/agent-human-in-loop @poe-code/task-list @poe-code/agent-defs @poe-code/config-mutations @poe-code/process-runner tiny-mcp-client tiny-stdio-mcp-server auth-store fast-string-width fast-wrap-ansi ignore jsonc-parser sisteransi smol-toml yaml"
   },
   "dependencies": {
     "commander": "^13.1.0",
@@ -116,8 +116,6 @@
     "jsonc-parser": "^3.3.1",
     "sisteransi": "^1.0.5",
     "smol-toml": "^1.3.0",
-    "uri-template": "^2.0.0",
-    "uri-template-lite": "^23.4.0",
     "yaml": "^2.8.2"
   },
   "files": [
@@ -153,12 +151,10 @@
     "jsonc-parser",
     "sisteransi",
     "smol-toml",
-    "uri-template",
-    "uri-template-lite",
     "yaml"
   ],
   "optionalDependencies": {
-    "toolcraft-schema": "0.0.117",
+    "toolcraft-schema": "0.0.118",
     "toolcraft-design": "^0.0.2",
     "@poe-code/frontmatter": "*",
     "@poe-code/agent-mcp-config": "*",

package/node_modules/pct-encode/.travis.yml

@@ -1,7 +0,0 @@
-language: node_js
-
-node_js:
-  - "0.11"
-  - "0.10"
-  - "0.8"
-  - "0.6"

package/node_modules/pct-encode/AUTHORS

@@ -1,2 +0,0 @@
-Andrei Neculau <andrei.neculau@gmail.com>
-Stephen Sugden <me@stephensugden.com>

package/node_modules/pct-encode/LICENSE

@@ -1,11 +0,0 @@
-Copyright (c) 2013, Stephen Sugden
-
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/node_modules/pct-encode/README.md

@@ -1,20 +0,0 @@
-# pct-encode
-
-Create versions of strings where characters that match a regular expression are percent encoded.
-
-## Synopsis
-
-```javascript
-var pctEncode = require("pct-encode");
-
-var encode = pctEncode(/\W/g);
-
-console.log(encode("UTF-8 in your URIs: ✓")); // UTF-8%20in%20your%20URIs%3A%20%E2%9C%93
-```
-
-## API
-
-### module.exports = function (regexp) -> function encode(string)
-
-Given a regular expression, this returns a function that takes a string and
-returns a copy with characters that match `regexp` percent-encoded.

package/node_modules/pct-encode/index.js

@@ -1,23 +0,0 @@
-module.exports = function pctEncode(regexp) {
-  regexp = regexp || /\W/g;
-  return function encode(string) {
-    string = String(string);
-    return string.replace(regexp, function (m) {
-      var c = m[0].charCodeAt(0)
-        , encoded = [];
-      if (c < 128) {
-        encoded.push(c);
-      } else if ((128 <= c && c < 2048)) {
-        encoded.push((c >> 6) | 192);
-        encoded.push((c & 63) | 128);
-      } else {
-        encoded.push((c >> 12) | 224);
-        encoded.push(((c >> 6) & 63) | 128);
-        encoded.push((c & 63) | 128);
-      }
-      return encoded.map(function (c) {
-        return '%' + c.toString(16).toUpperCase();
-      }).join('');
-    })
-  }
-}