sproutit-narwhal 0.1.106

data/lib/base16.js

@@ -0,0 +1,16 @@
+
+var util = require('util');
+var binary = require('binary');
+var struct = require('struct');
+
+exports.encode = function (n) {
+    var length = n.length;
+    var result = [];
+    var alphabet = struct.alphabet16Lower;
+    for (var i = 0; i < length; i++) {
+        n[i] = n[i] & 0xFF;
+        result.push(alphabet[(n.charCodeAt(i) >>> 4) & 0xF], alphabet[n.charCodeAt(i) & 0xF]);
+    }
+    return result.join('');
+};
+

data/lib/base64.js

@@ -0,0 +1,120 @@
+/* Copyright (C) 1999 Masanao Izumo <iz@onicos.co.jp>
+ * Version: 1.0
+ * LastModified: Dec 25 1999
+ * This library is free.  You can redistribute it and/or modify it.
+ */
+
+/* modified by Kris Kowal to add support for Binary for Narwhal */
+
+var encodeChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var decodeChars = [
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63,
+    52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1,
+    -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
+    15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
+    -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+    41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1
+];
+
+var binary = require('binary');
+
+exports.encode = function (str) {
+    var out, i, length;
+    var c1, c2, c3;
+
+    length = len(str);
+    i = 0;
+    out = [];
+    while(i < length) {
+        c1 = str.charCodeAt(i++) & 0xff;
+        if(i == length)
+        {
+            out.push(encodeChars.charCodeAt(c1 >> 2));
+            out.push(encodeChars.charCodeAt((c1 & 0x3) << 4));
+            out.push("=".charCodeAt(0));
+            out.push("=".charCodeAt(0));
+            break;
+        }
+        c2 = str.charCodeAt(i++);
+        if(i == length)
+        {
+            out.push(encodeChars.charCodeAt(c1 >> 2));
+            out.push(encodeChars.charCodeAt(((c1 & 0x3)<< 4) | ((c2 & 0xF0) >> 4)));
+            out.push(encodeChars.charCodeAt((c2 & 0xF) << 2));
+            out.push("=".charCodeAt(0));
+            break;
+        }
+        c3 = str.charCodeAt(i++);
+        out.push(encodeChars.charCodeAt(c1 >> 2));
+        out.push(encodeChars.charCodeAt(((c1 & 0x3)<< 4) | ((c2 & 0xF0) >> 4)));
+        out.push(encodeChars.charCodeAt(((c2 & 0xF) << 2) | ((c3 & 0xC0) >>6)));
+        out.push(encodeChars.charCodeAt(c3 & 0x3F));
+    }
+    return binary.ByteString(out).toString('ascii');
+};
+
+exports.decode = function (str) {
+    var c1, c2, c3, c4;
+    var i, length, out;
+
+    length = len(str);
+    i = 0;
+    out = [];
+    while(i < length) {
+        /* c1 */
+        do {
+            c1 = decodeChars[str.charCodeAt(i++) & 0xff];
+        } while(i < length && c1 == -1);
+        if(c1 == -1)
+            break;
+
+        /* c2 */
+        do {
+            c2 = decodeChars[str.charCodeAt(i++) & 0xff];
+        } while(i < length && c2 == -1);
+        if(c2 == -1)
+            break;
+
+        out.push(String.fromCharCode((c1 << 2) | ((c2 & 0x30) >> 4)));
+
+        /* c3 */
+        do {
+            c3 = str.charCodeAt(i++) & 0xff;
+            if(c3 == 61)
+                return out.join('');
+            c3 = decodeChars[c3];
+        } while(i < length && c3 == -1);
+        if(c3 == -1)
+            break;
+
+        out.push(String.fromCharCode(((c2 & 0xF) << 4) | ((c3 & 0x3C) >> 2)));
+
+        /* c4 */
+        do {
+            c4 = str.charCodeAt(i++) & 0xff;
+            if(c4 == 61)
+                return out.join('');
+            c4 = decodeChars[c4];
+        } while(i < length && c4 == -1);
+
+        if(c4 == -1)
+            break;
+
+        out.push(String.fromCharCode(((c3 & 0x03) << 6) | c4));
+    }
+
+    return out.join('');
+};
+
+var len = function (object) {
+    if (object.length !== undefined) {
+        return object.length;
+    } else if (object.getLength !== undefined) {
+        return object.getLength();
+    } else {
+        return undefined;
+    }
+};
+

data/lib/codec/base64.js

@@ -0,0 +1,8 @@
+var system = require("system");
+system.log.warn("codec/base64 is deprecated.  use base64 directly.");
+var base64 = require("base64");
+for (var name in base64) {
+    if (Object.prototype.hasOwnProperty.call(base64, name)) {
+        exports[name] = base64[name];
+    }
+}

data/lib/crc32.js

@@ -0,0 +1,60 @@
+
+var util = require('./util');
+
+/*** polynomials
+*/
+exports.polynomials = {
+    'ieee802_3': 0xEDB88320,
+    'castagnoli': 0x82F63B78,
+    'kooperman': 0xEB31D82E
+};
+
+/*** Table
+*/
+exports.Table = function (polynomial) {
+    var term, table = [];
+    for (var i = 0; i < 256; i++) {
+        term = i;
+        for (var j = 0; j < 8; j++) {
+            if (term & 1)
+                term = (term >>> 1) ^ polynomial;
+            else
+                term = term >>> 1;
+        }
+        table[i] = term;
+    }
+    return table;
+};
+
+/*** table
+*/
+exports.table = exports.Table(exports.polynomials.ieee802_3);
+
+/*** hash
+    returns the crc32 hash for a string as an integer.
+*/
+exports.hash = function (bin, table) {
+    if (util.no(table))
+        table = exports.table;
+    var crc = 0xFFFFFFFF;
+    for (var i = 0; i < bin.length; i ++) {
+        var x = bin.charCodeAt(i);
+        if (x & ~0xFF)
+            throw new Error(
+                "crc32 can only encode strings of bytes.  " +
+                "Consider using .toByteString(charset)"
+            );
+        crc = (crc >>> 8) ^ table[x ^ (crc & 0xFF)];
+    }
+    return ~crc;
+};
+
+/*
+
+    References
+    ==========
+
+    http://www.webtoolkit.info/
+    Javascript crc32
+
+*/

data/lib/file-bootstrap.js

@@ -0,0 +1,187 @@
+
+// NOTE: this file is used is the bootstrapping process,
+// so any "requires" must be accounted for in narwhal.js
+
+// use the "file" module as the exports object.
+var exports = require("file");
+var system = require("system");
+
+/* path manipulation, needed by the sandbox module in the 
+ * bootstrapping process before "require" is ready for use */
+
+if (/\bwindows\b/i.test(system.os)) {
+    exports.ROOT = "\\";
+    exports.SEPARATOR = "\\";
+    exports.ALT_SEPARATOR = "/";
+} else {
+    exports.ROOT = "/";
+    exports.SEPARATOR = "/";
+    exports.ALT_SEPARATOR = undefined;
+}
+
+// we need to make sure the separator regex is always in sync with the separators.
+// this caches the generated regex and rebuild if either separator changes.
+exports.SEPARATORS_RE = function() {
+    if (
+        separatorCached !== exports.SEPARATOR ||
+        altSeparatorCached !== exports.ALT_SEPARATOR
+    ) {
+        separatorCached = exports.SEPARATOR;
+        altSeparatorCached = exports.ALT_SEPARATOR;
+        separatorReCached = new RegExp("[" +
+            (separatorCached || '').replace(/[-[\]{}()*+?.\\^$|,#\s]/g, "\\$&") +
+            (altSeparatorCached || '').replace(/[-[\]{}()*+?.\\^$|,#\s]/g, "\\$&") +
+        "]", "g");
+    }
+    return separatorReCached;
+}
+var separatorCached, altSeparatorCached, separatorReCached;
+
+exports.join = function () {
+    // special case for root, helps glob
+    if (arguments.length == 1 && arguments[0] == "")
+        return exports.SEPARATOR; // [""] -> "/"
+    // ["", ""] -> "/",
+    // ["", "a"] -> "/a"
+    // ["a"] -> "a"
+    return exports.normal(Array.prototype.join.call(arguments, exports.SEPARATOR));
+};
+
+exports.split = function (path) {
+    var parts;
+    try {
+        parts =  String(path).split(exports.SEPARATORS_RE());
+    } catch (exception) {
+        throw new Error("Cannot split " + (typeof path) + ', "' + path + '"');
+    }
+    // this special case helps isAbsolute
+    // distinguish an empty path from an absolute path
+    // "" -> [] NOT [""]
+    if (parts.length == 1 && parts[0] == "")
+        return [];
+    // "a" -> ["a"]
+    // "/a" -> ["", "a"]
+    return parts;
+};
+
+exports.resolve = function () {
+    var root = "";
+    var parents = [];
+    var children = [];
+    var leaf = "";
+    for (var i = 0; i < arguments.length; i++) {
+        var path = String(arguments[i]);
+        if (path == "")
+            continue;
+        var parts = path.split(exports.SEPARATORS_RE());
+        if (exports.isAbsolute(path)) {
+            root = parts.shift() + exports.SEPARATOR;
+            parents = [];
+            children = [];
+        }
+        leaf = parts.pop();
+        if (leaf == "." || leaf == "..") {
+            parts.push(leaf);
+            leaf = "";
+        }
+        for (var j = 0; j < parts.length; j++) {
+            var part = parts[j];
+            if (part == "." || part == '') {
+            } else if (part == "..") {
+                if (children.length) {
+                    children.pop();
+                } else {
+                    if (root) {
+                    } else {
+                        parents.push("..");
+                    }
+                }
+            } else {
+                children.push(part);
+            }
+        };
+    }
+    path = parents.concat(children).join(exports.SEPARATOR);
+    if (path) leaf = exports.SEPARATOR + leaf;
+    return root + path + leaf;
+};
+
+exports.normal = function (path) {
+    return exports.resolve(path);
+};
+
+// XXX not standard
+exports.isAbsolute = function (path) {
+    // for absolute paths on any operating system,
+    // the first path component always determines
+    // whether it is relative or absolute.  On Unix,
+    // it is empty, so ['', 'foo'].join('/') == '/foo',
+    // '/foo'.split('/') == ['', 'foo'].
+    var parts = exports.split(path);
+    // split('') == [].  '' is not absolute.
+    // split('/') == ['', ''] is absolute.
+    // split(?) == [''] does not occur.
+    if (parts.length == 0)
+        return false;
+    return exports.isDrive(parts[0]);
+};
+
+// XXX not standard
+exports.isRelative = function (path) {
+    return !exports.isAbsolute(path);
+};
+
+// XXX not standard
+exports.isDrive = function (first) {
+    if (/\bwindows\b/i.test(system.os)) {
+        return /:$/.test(first);
+    } else {
+        return first == "";
+    }
+};
+
+/*** root
+    returns the Unix root path
+    or corresponding Windows drive
+    for a given path.
+*/
+// XXX not standard
+exports.root = function (path) {
+    if (!exports.isAbsolute(path))
+        path = require("file").absolute(path);
+    var parts = exports.split(path);
+    return exports.join(parts[0], '');
+};
+
+exports.dirname = function (path) {
+    var parts = exports.split(path);
+    // XXX needs to be sensitive to the root for
+    // Windows compatibility
+    parts.pop();
+    return exports.join.apply(null, parts) || ".";
+};
+
+// XXX the extension argument is not standard
+exports.basename = function (path, extension) {
+    var basename = path.split(exports.SEPARATORS_RE()).pop();
+    if (extension)
+        basename = basename.replace(
+            new RegExp(RegExp.escape(extension) + '$'),
+            ''
+        );
+    return basename;
+};
+
+exports.extension = function (path) {
+    path = exports.basename(path);
+    path = path.replace(/^\.*/, '');
+    var index = path.lastIndexOf(".");
+    return index <= 0 ? "" : path.substring(index);
+};
+
+// XXX not standard, deprecated
+exports.extname = function (path) {
+    system.log.warn('extname is deprecated in favor of extension');
+    return exports.extension(path);
+};
+

data/lib/file.js

@@ -0,0 +1,659 @@
+
+// NOTE: portions of the "file" module are implemented in "file-bootstrap" and "file-engine",
+// which are loaded at the bottom of this file to allow for overriding default implementations
+
+var io = require('io');
+
+/* streams */
+
+exports.open = function (path, mode, options) {
+
+    // it's possible to confuse options and mode,
+    // particularly with exports.read(path, options).
+    // if a mode string is passed into options, 
+    // tollerate it.
+    if (typeof options == 'string') {
+        options = {
+            mode: exports.mode(options)
+        }
+    }
+
+    // we'll channel all of the arguments through
+    // the options object, so create an empty one if none
+    // was given.
+    if (!options) 
+        options = {};
+
+    // if options were specified as the first (and
+    // presumably only) argument, use those options,
+    // overriding any in the options object if both
+    // were provided.
+    if (typeof path == 'object') {
+        for (var key in path) {
+            if (Object.prototype.hasOwnProperty.call(path, key)) {
+                options[key] = path[key];
+            }
+        }
+    }
+    // if the path is a string, however, write it
+    // onto the options object alone.
+    if (typeof path == 'string')
+        options.path = path;
+
+    // accumulate the mode from options.mode and 
+    // the mode arg through successive generations;
+    // coerce the options.mode to an object, suitable
+    // for updates
+    options.mode = exports.mode(options.mode);
+    // update options.mode with the mode argument
+    if (mode)
+        options.mode = exports.mode(mode, options.mode);
+
+
+    // channel all the options back into local variables
+    path = options.path;
+    mode = options.mode;
+    var permissions = options.permissions,
+        charset = options.charset,
+        buffering = options.buffering,
+        recordSeparator = options.recordSeparator,
+        fieldSeparator = options.fieldSeparator;
+
+    // and decompose the mode object
+    var read = mode.read,
+        write = mode.write,
+        append = mode.append,
+        update = mode.update,
+        binary = mode.binary;
+
+    // read by default
+    if (!(read || write || append))
+        read = mode.read = true;
+
+    // create a byte stream
+    var raw = exports.FileIO(path, mode, permissions);
+
+    // if we're in binary mode, just return the raw
+    // stream
+    if (binary)
+        return raw;
+
+    // otherwise, go through the courses to return the
+    // appropriate reader, writer, or updater, buffered,
+    // line buffered, and charset decoded/encoded
+    // abstraction
+
+    var lineBuffering = buffering == 1 || buffering === undefined && raw.isatty && raw.isatty();
+    // leaving buffering undefined is a signal to the engine implementation
+    //  that it ought to pick a good size on its own.
+    if (buffering < 0) {
+        throw new Error("invalid buffering size");
+    }
+    if (buffering === 0) {
+        throw new Error("can't have unbuffered text IO");
+    }
+
+    return new io.TextIOWrapper(raw, mode, lineBuffering, buffering, charset, options);
+
+};
+
+/*
+    idempotent normalization of acceptable formats for
+    file modes.
+*/
+exports.mode = function (mode, result) {
+    if (!result)
+        result = {
+            read: false,
+            write: false,
+            append: false,
+            update: false,
+            binary: false,
+            canonical: false,
+            exclusive: false
+        };
+    else if (typeof result != 'object')
+        throw new Error("Mode to update is not a proper mode object: " + result);
+
+    if (mode === undefined || mode === null) {
+    } else if (mode instanceof String || typeof mode == "string") {
+        mode.split("").forEach(function (option) {
+            if (option == 'r') {
+                result.read = true;
+            } else if (option == 'w') {
+                result.write = true;
+            } else if (option == 'a') {
+                result.append = true;
+            } else if (option == '+') {
+                result.update = false;
+            } else if (option == 'b') {
+                result.binary = true;
+            } else if (option == 't') {
+                result.binary = false;
+            } else if (option == 'c') {
+                result.canonical = true;
+            } else if (option == 'x') {
+                result.exclusive = true;
+            } else {
+                throw new Error("unrecognized mode option in mode: " + option);
+            }
+        });
+    } else if (mode instanceof Array) {
+        mode.forEach(function (option) {
+            if (Object.prototype.hasOwnProperty.call(result, option)) {
+                result[option] = true;
+            } else {
+                throw new Error("unrecognized mode option in mode: " + option);
+            }
+        });
+    } else if (mode instanceof Object) {
+        for (var option in mode) {
+            if (Object.prototype.hasOwnProperty.call(mode, option)) {
+                if (Object.prototype.hasOwnProperty.call(result, option)) {
+                    result[option] = !!mode[option];
+                } else {
+                    throw new Error("unrecognized mode option in mode: " + option);
+                }
+            }
+        }
+    } else {
+        throw new Error("unrecognized mode: " + mode);
+    }
+
+    return result;
+};
+
+/* read, write, &c */
+
+exports.read = function (path, options) {
+    path = String(path);
+    var file = exports.open(path, 'r', options);
+    try {
+        return file.read();
+    } finally {
+        file.close();
+    }
+};
+
+exports.write = function (path, data, options) {
+    path = String(path);
+    var file = exports.open(path, 'w', options);
+    try {
+        file.write(data);
+        file.flush();
+    } finally {
+        file.close();
+    }
+};
+
+exports.copy = function (source, target) {
+    source = exports.path(source);
+    target = exports.path(target);
+    source.open("rb").copy(target.open("wb")).close();
+};
+
+exports.list = function (path) {
+    return exports.listImpl(String(path || '') || ".");
+};
+
+exports.listTree = function (path) {
+    path = String(path || '');
+    if (!path)
+        path = ".";
+    var paths = [""];
+    exports.list(path).forEach(function (child) {
+        var fullPath = exports.join(path, child);
+        if (exports.isDirectory(fullPath)) {
+            paths.push.apply(paths, exports.listTree(fullPath).map(function(p) {
+                return exports.join(child, p);
+            }));
+        } else {
+            paths.push(child)
+        }
+    });
+    return paths;
+};
+
+exports.listDirectoryTree = function (path) {
+    path = String(path || '');
+    if (!path)
+        path = ".";
+    var paths = [""];
+    exports.list(path).forEach(function (child) {
+        var fullPath = exports.join(path, child);
+        if (exports.isDirectory(fullPath)) {
+            paths.push.apply(paths, exports.listDirectoryTree(fullPath).map(function(p) {
+                return exports.join(child, p);
+            }));
+        }
+    });
+    return paths;
+};
+
+exports.FNM_LEADING_DIR = 1 << 1;
+exports.FNM_PATHNAME    = 1 << 2;
+exports.FNM_PERIOD      = 1 << 3;
+exports.FNM_NOESCAPE    = 1 << 4;
+exports.FNM_CASEFOLD    = 1 << 5;
+exports.FNM_DOTMATCH    = 1 << 6;
+
+var fnmatchFlags = ["FNM_LEADING_DIR","FNM_PATHNAME","FNM_PERIOD","FNM_NOESCAPE","FNM_CASEFOLD","FNM_DOTMATCH"];
+
+exports.fnmatch = function (pattern, string, flags) {
+    var re = exports.patternToRegExp(pattern, flags);
+    //print("PATTERN={"+pattern+"} REGEXP={"+re+"}");
+    return re.test(string);
+}
+
+exports.patternToRegExp = function (pattern, flags) {
+    var options = {};
+    if (typeof flags === "number") {
+        fnmatchFlags.forEach(function(flagName) {
+            options[flagName] = !!(flags & exports[flagName]);
+        });
+    } else if (flags) {
+        options = flags;
+    }
+    
+    // FNM_PATHNAME: don't match separators
+    var matchAny = options.FNM_PATHNAME ? "[^"+RegExp.escape(exports.SEPARATOR)+"]" : ".";
+    
+    // FNM_NOESCAPE match "\" separately
+    var tokenizeRegex = options.FNM_NOESCAPE ?
+        /\[[^\]]*\]|{[^}]*}|[^\[{]*/g :
+        /\\(.)|\[[^\]]*\]|{[^}]*}|[^\\\[{]*/g;
+    
+    return new RegExp(
+        '^' + 
+        pattern.replace(tokenizeRegex, function (pattern, $1) {
+            // if escaping is on, always return the next character escaped
+            if (!options.FNM_NOESCAPE && (/^\\/).test(pattern) && $1) {
+                return RegExp.escape($1);
+            }
+            if (/^\[/.test(pattern)) {
+                var result = "[";
+                pattern = pattern.slice(1, pattern.length - 1);
+                // negation
+                if (/^[!^]/.test(pattern)) {
+                    pattern = pattern.slice(1);
+                    result += "^";
+                }
+                // swap any range characters that are out of order
+                pattern = pattern.replace(/(.)-(.)/, function(match, a, b) {
+                    return a.charCodeAt(0) > b.charCodeAt(0) ? b + "-" + a : match;
+                });
+                return result + pattern.split("-").map(RegExp.escape).join("-") + ']';
+            }
+            if (/^\{/.test(pattern))
+                return (
+                    '(' +
+                    pattern.slice(1, pattern.length - 1)
+                    .split(',').map(function (pattern) {
+                        return RegExp.escape(pattern);
+                    }).join('|') +
+                    ')'
+                );
+            return pattern
+            .replace(exports.SEPARATORS_RE(), exports.SEPARATOR)    
+            .split(new RegExp(
+                exports.SEPARATOR + "?" +
+                "\\*\\*" + 
+                exports.SEPARATOR + "?"
+            )).map(function (pattern) {
+                return pattern.split(exports.SEPARATOR).map(function (pattern) {
+                    if (pattern == "")
+                        return "\\.?";
+                    if (pattern == ".")
+                        return;
+                    if (pattern == "...")
+                        return "(|\\.|\\.\\.(" + exports.SEPARATOR + "\\.\\.)*?)";
+                    return pattern.split('*').map(function (pattern) {
+                        return pattern.split('?').map(function (pattern) {
+                            return RegExp.escape(pattern);
+                        }).join(matchAny);
+                    }).join(matchAny + '*');
+                }).join(RegExp.escape(exports.SEPARATOR));
+            }).join('.*?');
+        }) +
+        '$',
+        options.FNM_CASEFOLD ? "i" : ""
+    );
+};
+
+exports.copyTree = function(source, target, path) {
+    var sourcePath = (source = exports.path(source)).join(path);
+    var targetPath = (target = exports.path(target)).join(path);
+    if (exports.exists(targetPath))
+        throw new Error("file exists: " + targetPath);
+    if (exports.isDirectory(sourcePath)) {
+        exports.mkdir(targetPath);
+        exports.list(sourcePath).forEach(function (name) {
+            exports.copyTree(source, target, exports.join(path, name));
+        });
+    } else {
+        exports.copy(sourcePath, targetPath);
+    }
+};
+
+exports.match = function (path, pattern) {
+    return exports.patternToRegExp(pattern).test(path);
+};
+
+exports.glob = function (pattern, flags) {
+    pattern = String(pattern || '');
+    var parts = exports.split(pattern);
+    if (exports.isAbsolute(pattern))
+        parts.unshift(exports.join(parts.shift(), parts.shift()));
+    var paths = ['.'];
+    
+    if (parts[parts.length-1] == "**")
+        parts[parts.length-1] = "*";
+    
+    parts.forEach(function (part) {
+        if (part == "") {
+        } else if (part == "**") {
+            paths = globTree(paths);
+        } else if (part == "...") {
+            paths = globHeredity(paths);
+        } else if (/[\\\*\?\[{]/.test(part)) {
+            paths = globPattern(paths, part, flags);
+        } else {
+            paths = paths.map(function (path) {
+                if (path)
+                    return exports.join(path, part);
+                return part;
+            }).filter(function (path) {
+                return exports.exists(path);
+            });
+        }
+
+        // uniqueness
+        var visited = {};
+        paths = paths.filter(function (path) {
+            var result = !Object.prototype.hasOwnProperty.call(visited, path);
+            visited[path] = true;
+            return result;
+        });
+
+    });
+    
+    if (paths[0] === "") paths.shift();
+    
+    return paths;
+};
+
+var globTree = function (paths) {
+    return Array.prototype.concat.apply(
+        [],
+        paths.map(function (path) {
+            if (!exports.isDirectory(path))
+                return [];
+            return exports.listDirectoryTree(path).map(function (child) {
+                return exports.join(path, child);
+            });
+        })
+    );
+};
+
+var globHeredity = function (paths) {
+    return Array.prototype.concat.apply(
+        [],
+        paths.map(function (path) {
+            var isRelative = exports.isRelative(path);
+            var heredity = [];
+            var parts = exports.split(exports.absolute(path));
+            if (parts[parts.length - 1] == "")
+                parts.pop();
+            while (parts.length) {
+                heredity.push(exports.join.apply(null, parts));
+                parts.pop();
+            }
+            if (isRelative) {
+                heredity = heredity.map(function (path) {
+                    return exports.relative("", path);
+                });
+            }
+            return heredity;
+        })
+    );
+};
+
+var globPattern = function (paths, pattern, flags) {
+    var re = exports.patternToRegExp(pattern, flags);
+    // print("PATTERN={"+pattern+"} REGEXP={"+re+"}");
+    // use concat to flatten result arrays
+    return Array.prototype.concat.apply([], paths.map(function (path) {
+        if (!exports.isDirectory(path))
+            return [];
+        return [/*".", ".."*/].concat(exports.list(path)).filter(function (name) {
+            return re.test(name);
+        }).map(function (name) {
+            if (path)
+                return exports.join(path, name);
+            return name;
+        }).filter(function (path) {
+            return exports.exists(path);
+        });
+    }));
+};
+
+exports.globPaths = function (pattern, flags) {
+    return exports.glob(pattern, flags).map(function (path) {
+        return new exports.Path(path);
+    });
+};
+
+exports.rmtree = function(path) {
+    if (exports.isLink(path)) {
+        exports.remove(path);
+    } else
+    if (exports.isDirectory(path)) {
+        exports.list(path).forEach(function (name) {
+            exports.rmtree(exports.join(path, name));
+        });
+        exports.rmdir(path);
+    } else {
+        exports.remove(path);
+    }
+};
+
+/* path manipulation */
+
+exports.relative = function (source, target) {
+    if (!target) {
+        target = source;
+        source = exports.cwd() + '/';
+    }
+    source = exports.absolute(source);
+    target = exports.absolute(target);
+    source = source.split(exports.SEPARATORS_RE());
+    target = target.split(exports.SEPARATORS_RE());
+    source.pop();
+    while (
+        source.length &&
+        target.length &&
+        target[0] == source[0]) {
+        source.shift();
+        target.shift();
+    }
+    while (source.length) {
+        source.shift();
+        target.unshift("..");
+    }
+    return target.join(exports.SEPARATOR);
+};
+
+exports.absolute = function (path) {
+    return exports.resolve(exports.join(exports.cwd(), ''), path);
+};
+
+/* path wrapper, for chaining */
+
+exports.path = function (/*path*/) {
+    if (arguments.length == 1 && arguments[0] == "")
+        return exports.Path("");
+    return exports.Path(exports.join.apply(exports, arguments));
+};
+
+var Path = exports.Path = function (path) {
+    if (!(this instanceof exports.Path))
+        return new exports.Path(path);
+    this.toString = function () {
+        return path;
+    };
+};
+
+Path.prototype = new String();
+
+Path.prototype.valueOf = function () {
+    return this.toString();
+};
+
+Path.prototype.join = function () {
+    return exports.Path(
+        exports.join.apply(
+            null,
+            [this.toString()].concat(Array.prototype.slice.call(arguments))
+        )
+    );
+};
+
+Path.prototype.resolve = function () {
+    return exports.Path(
+        exports.resolve.apply(
+            null,
+            [this.toString()].concat(Array.prototype.slice.call(arguments))
+        )
+    );
+};
+
+Path.prototype.to = function (target) {
+    return exports.Path(exports.relative(this.toString(), target));
+};
+
+Path.prototype.from = function (target) {
+    return exports.Path(exports.relative(target, this.toString()));
+};
+
+Path.prototype.glob = function (pattern, flags) {
+    if (!this.isDirectory())
+        return [];
+    if (this.toString())
+        return exports.glob(exports.join(this, pattern), flags).map(function(path) {
+            return this.join("").relative(path).toString();
+        }, this).filter(function(path) { return !!path });
+    return exports.glob(pattern);
+};
+
+Path.prototype.globPaths = function (pattern, flags) {
+    if (!this.isDirectory())
+        return [];
+    if (this.toString()) 
+        return exports.glob(exports.join(this, pattern), flags).map(function (path) {
+            return this.join("").relative(path);
+            //return new exports.Path(path);
+        }, this).filter(function(path) { return !!path.toString() });
+    return exports.glob(pattern, flags);
+};
+
+var pathed = [
+    'absolute',
+    'basename',
+    'canonical',
+    'dirname',
+    'normal',
+    'relative'
+];
+
+for (var i = 0; i < pathed.length; i++) {
+    var name = pathed[i];
+    Path.prototype[name] = (function (name) {
+        return function () {
+            return exports.Path(exports[name].apply(
+                this,
+                [this.toString()].concat(Array.prototype.slice.call(arguments))
+            ));
+        };
+    })(name);
+}
+
+var pathIterated = [
+    'list',
+    'listTree'
+];
+
+for (var i = 0; i < pathIterated.length; i++) {
+    var name = pathIterated[i];
+
+    // create the module-scope variant
+    exports[name + 'Paths'] = (function (name) {
+        return function () {
+            return exports[name].apply(exports, arguments).map(function (path) {
+                return new exports.Path(path);
+            });
+        };
+    })(name);
+
+    // create the Path object variant
+    Path.prototype[name + 'Paths'] = (function (name) {
+        return function () {
+            var self = this;
+            return exports[name](this).map(function (path) {
+                return self.join(path);
+            });
+        };
+    })(name);
+}
+
+var nonPathed = [
+    'chmod',
+    'chown',
+    'copy',
+    'exists',
+    'extension',
+    'isDirectory',
+    'isFile',
+    'isLink',
+    'isReadable',
+    'isWritable',
+    'link',
+    'linkExists',
+    'list',
+    'listTree',
+    'mkdir', 
+    'mkdirs',
+    'move',
+    'mtime',
+    'open',
+    'read',
+    'remove',
+    'rename',
+    'rmdir',
+    'rmtree',
+    'size',
+    'split',
+    'stat',
+    'symlink',
+    'touch',
+    'write'
+];
+
+for (var i = 0; i < nonPathed.length; i++) {
+    var name = nonPathed[i];
+    Path.prototype[name] = (function (name) {
+        return function () {
+            var result = exports[name].apply(
+                this,
+                [this.toString()].concat(Array.prototype.slice.call(arguments))
+            );
+            if (result === undefined)
+                result = this;
+            return result;
+        };
+    })(name);
+}
+
+// load "file-bootstrap" and "file-engine", which in turn load "file" and modify it's module object.
+// "engine" gets priority so it's loaded last.
+require("file-bootstrap");
+require("file-engine");