Import Debian changes 4.12.4-1

freeipa (4.12.4-1) unstable; urgency=medium
.
  * New upstream release.
    - CVE-2024-11029 (Closes: #1093383)
    - CVE-2025-4404 (Closes: #1108050)
  * control: Demote libnss-myhostname to Suggests. (ref. #1006829)
  * patches: Fix samba lock directory location. (Closes: #1012593)
  * patches: Map nobody group to nogroup on Debian. (Closes: #1012592)
.
freeipa (4.12.2-3) unstable; urgency=medium
.
  * control: Add libnss-myhostname to client depends. (Closes: #1006829)
  * control: Add python3-ifaddr to ipalib depends. (Closes: #1089716)
  * control: Add python3-sphinx to build-depends. (Closes: #1003179,
    #1044642, #1049799)
.
freeipa (4.12.2-2) unstable; urgency=medium
.
  * control: Migrate to bind9-dnsutils. (Closes: #1094939)
.
freeipa (4.12.2-1) unstable; urgency=medium
.
  * New upstream release.
    - CVE-2024-2698 (Closes: #1077682)
    - CVE-2024-3183 (Closes: #1077683)
  * control: Drop conflicts on systemd-timesyncd as upstream recognizes
    it now. (Closes: #1072168)
  * use-raw-strings.diff: Dropped, upstream.
  * rules: Fix installing bash-completions. (Closes: #1089329)
  * control: Drop python3-nose from build-depends, unused. (Closes:
    #1018359)
.
freeipa (4.11.1-2.1) unstable; urgency=medium
.
  * Non-maintainer upload.
  * Replace systemd Build-Depends with systemd-dev for systemd.pc.
    (Closes: #1060469)
.
freeipa (4.11.1-2) unstable; urgency=medium
.
  * use-raw-strings.diff: Import patch from upstream to fix noise when
    installing. (LP: #2060298)
  * map-ssh-service.diff: Map sshd service to use ssh.service. (LP:
    #2061055)
.
freeipa (4.11.1-1) unstable; urgency=medium
.
  * New upstream release.
  * control: Add sssd-passkey to freeipa-client Recommends.
  * control.server: Drop python3-paste from python3-ipatests depends,
    obsolete.
  * control, rules: Replace hardcoded librpm9 depends. (Closes:
    #1067570)
.
freeipa (4.10.2-2) unstable; urgency=medium
.
  [ Timo Aaltonen ]
  * control: Bump certmonger dependency.
.
  [ Helmut Grohne ]
  * Fix FTBFS when systemd.pc changes systemdsystemunitdir. (Closes:
    #1052641)
.
freeipa (4.10.2-1) unstable; urgency=medium
.
  * New upstream release.
  * control: Bump sssd, bind9 depends.
  * source: Update extend-diff-ignore.
  * copyright, source: Fix some lintian issues/overrides.
  * server-trust-ad: Add a lintian override for the samba plugin rpath.
  * source: Add a lintian override for client-only build; empty-debian-
    tests-control.
.
freeipa (4.9.11-1) unstable; urgency=medium
.
  * New upstream release. (Closes: #1029070)
  * control: Add systemd-timesyncd to freeipa-client Conflicts. (Closes:
    #1008195)
  * patches: Drop upstreamed patches.
  * source: Extend diff-ignore.
  * server.install: Updated.
.
freeipa (4.9.8-1) unstable; urgency=medium
.
  * New upstream release.
  * patches: Drop upstreamed patch.
  * server.install: Updated.
  * Build only the client in order to be able to backport to bullseye.
    (Closes: #996946)
  * control: Depend on librpm9 instead of librpm8.
  * tests: Disabled for a client-only build.
.
freeipa (4.9.7-3) unstable; urgency=medium
.
  * tests: Set KRB5_TRACE to use stderr.
  * patches: Fix apache group properly.
  * client: Move .tmpfile -> .tmpfiles.
  * control: Bump debhelper to 13, gain dh_installtmpfiles being run.
  * control, rules: Add --without-ipa-join-xml and drop libxmlrpc from depends.
  * server.postinst: Drop creating old ccaches for mod_auth_gssapi, obsolete.
  * server.postinst: Drop old upgrade rules.
  * patches: Fix named keytab name.
.
freeipa (4.9.7-2) unstable; urgency=medium
.
  * lintian: Drop override on python-script-but-no-python-dep, which doesn't
    exist anymore.
  * rules: Add fortify flag to CFLAGS, as CPPFLAGS isn't used by the project.
  * ci: Drop allowed failure for blhc, it passes now.
  * control: Build-depend on libcurl4-openssl-dev.
  * fix-paths.diff: Fix some paths in ipaplatform/base.
  * fix-apache-group.diff: Fix apache group name in ipa.conf tmpfile.
  * control: Depend on gpg instead of gnupg.
  * control: Drop libwbclient-sssd from freeipa-client-samba Depends.
  * patches: Import a patch to fix ipa cert-find. (Closes: #997952)
.
freeipa (4.9.7-1) unstable; urgency=medium
.
  * New upstream release.
  * control: Drop obsolete depends on python3-nss.
  * pkcs11-openssl-for-bind.diff,
    migrate-to-gpg.diff,
    use-bind9.16.diff,
    fix-chrony-service-name.diff:
    - Dropped, upstream.
  * watch: Fixed to find upstream rc's.
  * source: Update extend-diff-ignore.
  * control: Add libcurl-dev, libjansson-dev and libpwquality-dev to
    build-depends.
  * install: Added new files.
  * rules: Drop ipasphinx files for now.
  * control: Drop dependency on custodia, not needed.
  * control: Bump 389-ds-base depends.
  * control: Drop python3-coverage depends, it's not used.
  * control: Bump dogtag depends.

debian/README.source

@@ -0,0 +1,7 @@
+freeipa
+
+Upstream does not ship unminified copies of various javascript files, so we must ship them
+in debian/missing-sources. Minified build.js, dojo.js and freeipa/{app,core}.js
+are built with a certain set of modules, so those bits are under missing-sources/{build,dojo}.
+The list of modules needed for the build are taken from install/ui/src/build.profile.js,
+install/ui/src/dojo.profile.js and install/ui/src/webui.profile.js.

debian/TODO

@@ -0,0 +1,3 @@
+TODO
+
+- Bundle OpenSans fonts? Fallback works fine though

debian/changelog

@@ -0,0 +1,911 @@
+freeipa (4.12.4-1) unstable; urgency=medium
+
+  * New upstream release.
+    - CVE-2024-11029 (Closes: #1093383)
+    - CVE-2025-4404 (Closes: #1108050)
+  * control: Demote libnss-myhostname to Suggests. (ref. #1006829)
+  * patches: Fix samba lock directory location. (Closes: #1012593)
+  * patches: Map nobody group to nogroup on Debian. (Closes: #1012592)
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Wed, 25 Jun 2025 12:40:45 +0300
+
+freeipa (4.12.2-3) unstable; urgency=medium
+
+  * control: Add libnss-myhostname to client depends. (Closes: #1006829)
+  * control: Add python3-ifaddr to ipalib depends. (Closes: #1089716)
+  * control: Add python3-sphinx to build-depends. (Closes: #1003179,
+    #1044642, #1049799)
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Tue, 04 Feb 2025 21:06:42 +0200
+
+freeipa (4.12.2-2) unstable; urgency=medium
+
+  * control: Migrate to bind9-dnsutils. (Closes: #1094939)
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Sat, 01 Feb 2025 20:09:51 +0200
+
+freeipa (4.12.2-1) unstable; urgency=medium
+
+  * New upstream release.
+    - CVE-2024-2698 (Closes: #1077682)
+    - CVE-2024-3183 (Closes: #1077683)
+  * control: Drop conflicts on systemd-timesyncd as upstream recognizes
+    it now. (Closes: #1072168)
+  * use-raw-strings.diff: Dropped, upstream.
+  * rules: Fix installing bash-completions. (Closes: #1089329)
+  * control: Drop python3-nose from build-depends, unused. (Closes:
+    #1018359)
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Mon, 09 Dec 2024 15:34:56 +0200
+
+freeipa (4.11.1-2.1) unstable; urgency=medium
+
+  * Non-maintainer upload.
+  * Replace systemd Build-Depends with systemd-dev for systemd.pc.
+    (Closes: #1060469)
+
+ -- Michael Biebl <biebl@debian.org>  Wed, 17 Jul 2024 19:35:06 +0200
+
+freeipa (4.11.1-2) unstable; urgency=medium
+
+  * use-raw-strings.diff: Import patch from upstream to fix noise when
+    installing. (LP: #2060298)
+  * map-ssh-service.diff: Map sshd service to use ssh.service. (LP:
+    #2061055)
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Fri, 12 Apr 2024 14:31:35 +0300
+
+freeipa (4.11.1-1) unstable; urgency=medium
+
+  * New upstream release.
+  * control: Add sssd-passkey to freeipa-client Recommends.
+  * control.server: Drop python3-paste from python3-ipatests depends,
+    obsolete.
+  * control, rules: Replace hardcoded librpm9 depends. (Closes:
+    #1067570)
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Wed, 10 Apr 2024 15:59:30 +0300
+
+freeipa (4.10.2-2) unstable; urgency=medium
+
+  [ Timo Aaltonen ]
+  * control: Bump certmonger dependency.
+
+  [ Helmut Grohne ]
+  * Fix FTBFS when systemd.pc changes systemdsystemunitdir. (Closes:
+    #1052641)
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Wed, 18 Oct 2023 12:46:48 +0300
+
+freeipa (4.10.2-1) unstable; urgency=medium
+
+  * New upstream release.
+  * control: Bump sssd, bind9 depends.
+  * source: Update extend-diff-ignore.
+  * copyright, source: Fix some lintian issues/overrides.
+  * server-trust-ad: Add a lintian override for the samba plugin rpath.
+  * source: Add a lintian override for client-only build; empty-debian-
+    tests-control.
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Thu, 10 Aug 2023 11:16:37 +0300
+
+freeipa (4.9.11-1) unstable; urgency=medium
+
+  * New upstream release. (Closes: #1029070)
+  * control: Add systemd-timesyncd to freeipa-client Conflicts. (Closes:
+    #1008195)
+  * patches: Drop upstreamed patches.
+  * source: Extend diff-ignore.
+  * server.install: Updated.
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Wed, 18 Jan 2023 18:22:38 +0200
+
+freeipa (4.9.8-1) unstable; urgency=medium
+
+  * New upstream release.
+  * patches: Drop upstreamed patch.
+  * server.install: Updated.
+  * Build only the client in order to be able to backport to bullseye.
+    (Closes: #996946)
+  * control: Depend on librpm9 instead of librpm8.
+  * tests: Disabled for a client-only build.
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Wed, 15 Dec 2021 16:41:25 +0200
+
+freeipa (4.9.7-3) unstable; urgency=medium
+
+  * tests: Set KRB5_TRACE to use stderr.
+  * patches: Fix apache group properly.
+  * client: Move .tmpfile -> .tmpfiles.
+  * control: Bump debhelper to 13, gain dh_installtmpfiles being run.
+  * control, rules: Add --without-ipa-join-xml and drop libxmlrpc from depends.
+  * server.postinst: Drop creating old ccaches for mod_auth_gssapi, obsolete.
+  * server.postinst: Drop old upgrade rules.
+  * patches: Fix named keytab name.
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Thu, 18 Nov 2021 21:20:16 +0200
+
+freeipa (4.9.7-2) unstable; urgency=medium
+
+  * lintian: Drop override on python-script-but-no-python-dep, which doesn't
+    exist anymore.
+  * rules: Add fortify flag to CFLAGS, as CPPFLAGS isn't used by the project.
+  * ci: Drop allowed failure for blhc, it passes now.
+  * control: Build-depend on libcurl4-openssl-dev.
+  * fix-paths.diff: Fix some paths in ipaplatform/base.
+  * fix-apache-group.diff: Fix apache group name in ipa.conf tmpfile.
+  * control: Depend on gpg instead of gnupg.
+  * control: Drop libwbclient-sssd from freeipa-client-samba Depends.
+  * patches: Import a patch to fix ipa cert-find. (Closes: #997952)
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Wed, 17 Nov 2021 15:40:55 +0200
+
+freeipa (4.9.7-1) unstable; urgency=medium
+
+  * New upstream release.
+  * control: Drop obsolete depends on python3-nss.
+  * pkcs11-openssl-for-bind.diff,
+    migrate-to-gpg.diff,
+    use-bind9.16.diff,
+    fix-chrony-service-name.diff:
+    - Dropped, upstream.
+  * watch: Fixed to find upstream rc's.
+  * source: Update extend-diff-ignore.
+  * control: Add libcurl-dev, libjansson-dev and libpwquality-dev to
+    build-depends.
+  * install: Added new files.
+  * rules: Drop ipasphinx files for now.
+  * control: Drop dependency on custodia, not needed.
+  * control: Bump 389-ds-base depends.
+  * control: Drop python3-coverage depends, it's not used.
+  * control: Bump dogtag depends.
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Wed, 13 Oct 2021 15:19:00 +0300
+
+freeipa (4.8.10-2) unstable; urgency=medium
+
+  * client: Drop obsolete nssdb migration, which is now causing an
+    error. (Closes: #971363)
+  * Move ipa-epn service to -client-epn package.
+  * control: Rebuild against new krb5.
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Mon, 23 Nov 2020 20:48:56 +0200
+
+freeipa (4.8.10-1) unstable; urgency=medium
+
+  * New upstream release.
+  * control: Build freeipa-client-epn only where nodejs is available.
+    (Closes: #970230)
+  * install: ipa-print-pac belongs to the server instead of -client-epn.
+  * control, pkcs11-openssl-for-bind.diff: Add support for bind 9.16.
+    (LP: #1874568)
+  * fix-chrony-service-name.diff: Map to correct chrony service name.
+    (Closes: #968428)
+  * freeipa-client-epn.install: Add epn.conf.
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Mon, 28 Sep 2020 13:12:26 +0300
+
+freeipa (4.8.8-2) unstable; urgency=medium
+
+  * copyright: Fix duplicate-globbing-patterns lintian error.
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Wed, 02 Sep 2020 11:05:55 +0300
+
+freeipa (4.8.8-1) unstable; urgency=medium
+
+  * New upstream release.
+    - CVE-2020-1722 (Closes: #966200)
+  * use-bind9.16.diff: Fix some paths to what's in bind9 9.16.
+  * write-out-only-one-cert-per-file.diff, tasks-fixes.diff: Dropped,
+    upstream.
+  * control: Replace node-uglify build-dependency with python3-rjsmin.
+  * control: Add freeipa-client-epn package.
+  * .install: Updated.
+  * control: Drop libnss3-dev from build-depends, use libssl for util &
+    libotp.
+  * fix-sssd-socket-activation.diff: Don't add a 'services =' line on
+    sssd.conf. (LP: #1879083)
+  * sources: Fix some lintian errors.
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Wed, 02 Sep 2020 08:05:51 +0300
+
+freeipa (4.8.6-1) unstable; urgency=medium
+
+  * New upstream release.
+  * pki-proxy-Don-t-rely-on-running-apache-until-it-s-co.patch: Dropped,
+    upstream.
+  * migrate-to-gpg.diff: Use gpg instead of gpg2, update dependencies.
+    (Closes: #919062)
+  * control: Bump gssproxy depends.
+  * control: Relax apache2 dependency so it works on ubuntu.
+  * control: Bump policy to 4.5.0.
+  * control: Fix some M-A issues.
+  * control: Drop the dummy freeipa-admintools package.
+  * source: Update diff-ignore.
+  * rules: Don't remove po/ipa.pot on clean.
+  * tasks-fixes.diff: Use enable/disable_ldap_automount from base,
+    parse_ipa_version from redhat. Add librpm8 to python3-ipalib Depends.
+  * dnssec-race-wa.diff: Work-around racy dnssec setup, the socket isn't
+    necessarily ready when doing policy import.
+  * control: Update bind9-utils dependency.
+  * control: Bump depends on opendnssec.
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Tue, 07 Apr 2020 06:28:03 +0300
+
+freeipa (4.8.5-1) unstable; urgency=medium
+
+  * New upstream release.
+  * control: Drop client from freeipa-tests depends.
+  * Fix-font-awesome-path.patch: Dropped, upstream.
+  * fix-ods-conf-template.diff: Dropped, upstream.
+  * Use debhelper-compat.
+  * Add debian/gitlab-ci.yml.
+    - allow blhc and piuparts to fail
+  * write-out-only-one-cert-per-file.diff: Fix writing CA cert to file.
+  * tests: Make failure an actual failure again, and dump only last 2000
+    lines on failure, also from ipaclient log.
+  * rules: Import architecture.mk.
+  * source: Update extend-diff-ignore.
+  * server.install: Updated.
+  * pki-proxy-Don-t-rely-on-running-apache-until-it-s-co.patch: Fix
+    httpd_proxy install.
+  * control: Bump dependency on apache2 to where mod_proxy_ajp got fixed.
+  * tests: Add sudo to dependencies for dogtag.
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Wed, 25 Mar 2020 19:42:37 +0200
+
+freeipa (4.8.3-1) unstable; urgency=medium
+
+  * New upstream release.
+    - CVE-2019-10195: Don't log passwords embedded in commands in calls
+      using batch
+    - CVE-2019-14867: Make sure to have storage space for tag
+  * Fix-font-awesome-path.patch: Fix the path to font-awesome dir. (LP:
+    #1853863)
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Tue, 26 Nov 2019 20:14:47 +0200
+
+freeipa (4.8.2-1) unstable; urgency=medium
+
+  * New upstream release.
+  * control: Server needs to depend on the py3 version of mod-wsgi.
+  * server.install: Updated.
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Wed, 20 Nov 2019 19:58:42 +0200
+
+freeipa (4.8.1-2) unstable; urgency=medium
+
+  * client.postinst: Migrate checks to python3. (Closes: #936555)
+  * server.postinst: Let ipactl run the upgrader when needed, drop it from here.
+  * control: Add python3-pki-base to python3-ipaserver depends.
+  * control: Add ssl-cert to freeipa-server depends.
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Thu, 12 Sep 2019 00:30:23 +0300
+
+freeipa (4.8.1-1) experimental; urgency=medium
+
+  * New upstream release.
+  * Drop upstreamed patches.
+  * install: Updated.
+  * fix-ods-conf-template.diff: Drop an obsolete conf option.
+  * rules: Rework gentarball target.
+  * control: Bump policy to 4.4.0.
+  * Bump debhelper compat to 12.
+  * Migrate to python3.
+  * d/s/local-options: Updated.
+  * install: Updated.
+  * control, install: Add freeipa-client-samba.
+  * d/pydist-overrides: Updated.
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Sun, 08 Sep 2019 00:18:39 +0300
+
+freeipa (4.7.2-3) unstable; urgency=medium
+
+  * control: Move python-jwcrypto to python-ipaserver depends.
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Mon, 06 May 2019 08:43:34 +0300
+
+freeipa (4.7.2-2+exp1) experimental; urgency=medium
+
+  * rules: Build the server for experimental.
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Tue, 12 Feb 2019 16:05:05 +0200
+
+freeipa (4.7.2-2) unstable; urgency=medium
+
+  * tests: Disabled, they are for the server.
+  * Split server build-deps from the stub.
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Tue, 12 Feb 2019 16:02:08 +0200
+
+freeipa (4.7.2-1) unstable; urgency=medium
+
+  * New upstream release.
+  * client.tmpfile: Use /run instead of /var/run.
+  * control.common: Use same arch set on node-uglify build-dep as for
+    nodejs. (Closes: #918579)
+  * fix-fontawesome-path.diff: Refreshed.
+  * rules: Build only the client until Dogtag works again.
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Tue, 05 Feb 2019 12:39:34 +0200
+
+freeipa (4.7.1-3) unstable; urgency=medium
+
+  * control: Replace libsvrcore-dev build-dep with 389-ds-base-dev.
+  * tests: Install only the packages which are used for testing.
+  * rules: Don't run git on clean. (Closes: #912202)
+  * control: Nodejs is not available on all archs, build server packages
+    only where it is.
+  * control: Add systemd to python-ipalib depends. (Closes: #851158)
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Thu, 06 Dec 2018 02:22:35 +0200
+
+freeipa (4.7.1-2) unstable; urgency=medium
+
+  * control: Change python-nose to -mock on python-ipatests Depends.
+  * fix-oddjobd-conf.diff: Fix path to org.freeipa.server.conncheck.
+  * server.postinst: Fix a typo.
+  * fix-fontawesome-path.diff: Fix upgrade.
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Thu, 18 Oct 2018 14:30:44 +0300
+
+freeipa (4.7.1-1) unstable; urgency=medium
+
+  * New upstream release.
+    - fix-replicainstall.diff dropped, not applicable anymore
+    - ipa-httpd-pwdreader-force-fqdn.diff dropped, obsolete
+    - refresh patches
+    - server: drop ipa-replica-prepare
+  * dont-migrate-to-authselect.diff We don't have authselect, so just
+    return true when trying to migrate to it. (LP: #1793994)
+  * control: Move client dependency on chrony to recommends. (Closes:
+    #909803)
+  * control: Build server on any arch again.
+  * tests: Don't fail the tests, just dump the log if something goes
+    wrong.
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Tue, 09 Oct 2018 10:30:09 +0300
+
+freeipa (4.7.0-1) unstable; urgency=medium
+
+  * New upstream release. (LP: #1772447, #1772450)
+    - fix-version.diff: Dropped, not needed
+    - hack-duplicate-cert-directive.diff: Dropped, fixed upstream
+    - ldap-multiarch.diff: Dropped, fixed upstream
+    - support-pam-mkhomedir.diff: Dropped, fixed upstream
+    - fix-apache-ssl-setup.diff: Dropped, fixed upstream
+    - fix-httpd-group.diff: Dropped, fixed upstream
+    - fix-named-conf-template.diff: Dropped, fixed upstream
+    - fix-paths.diff: Dropped, fixed upstream
+    - refresh patches
+  * tests/server-install: Fix the fake domain, single label domains are not
+    supported anymore.
+  * server.postinst: Fix upgrade from earlier version.
+  * fix-fontawesome-path.diff: Fix the path to font-awesome. (LP:
+    #1772921)
+  * fix-krb5kdc-cert-path.diff: Apache can't access KDC certs, move them
+    to /var/lib/ipa/certs. (LP: #1772447)
+  * ipa-httpd-pwdreader-force-fqdn.diff: Make sure HOSTNAME is a FQDN. (LP:
+    #1769485)
+  * control: Add libjs-scriptaculous to server depends.
+  * fix-gzip-path.diff: Fix path to gzip. (LP: #1778236)
+  * control, rules: Switch rhino to nodejs for ui build.
+  * d/s/local-options: Add some files to ignore.
+  * control, copyright: Add node-uglify to build-depends, the embedded
+    copy was removed.
+  * control, fix-py3-lesscpy-name.diff: Add python3-lesscpy to build-
+    depends, call the binary with the correct name.
+  * control: Add python3-pkg-resources to build-depends.
+  * client.install: Add new template.
+  * control: Update vcs urls.
+  * control: Mark priority as optional.
+  * control, rules: Bump dh to 11.
+  * control: Add adduser to server depends.
+  * source/lintian-overrides: Updated.
+  * control: Bump policy to 4.1.5.
+  * control: Update maintainer list address.
+  * control: Build the server only on archs where 389-ds-base is
+    available.
+  * control: Bump python-ldap build-dep to 3.1.
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Fri, 28 Sep 2018 14:10:34 +0300
+
+freeipa (4.7.0~pre1+git20180411-2) experimental; urgency=medium
+
+  * fix-bind-ldap-so-path.diff: Dropped, the plugin uses non-MA path
+    now, fix depends to match.
+  * control: Add python-augeas to python-ipaclient depends. (LP: #1764615)
+  * ldap-multiarch.diff: Replace hack-libarch.diff with a new patch to
+    support more than x86. (LP: #1600634)
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Tue, 17 Apr 2018 23:47:32 +0300
+
+freeipa (4.7.0~pre1+git20180411-1) experimental; urgency=medium
+
+  * New upstream prerelease + git snapshot.
+  * tests: Fix whitespace.
+  * client.dirs: Add /var/lib/ipa-client/pki.
+  * server.post*: Enable session, session_cookie apache modules.
+  * control: Add sssd-dbus to server Depends.
+  * fix-httpd-group.diff: Fix apache group for Debian.
+  * control: Bump dependency on certmonger.
+  * support-pam-mkhomedir.diff: Add support for enabling pam_mkhomedir.
+    (LP: #1336869)
+  * control: Add libsss-certmap-dev to build-depends.
+  * control: Drop hardcoded libcurl3 dependency from client.
+  * control*, rules: Add support for client-only build.
+  * Fold admintools into the client package.
+  * fix-bind-ldap-so-path.diff: Use multiarch path to bind/ldap.so.
+  * fix-ipa-conf.diff: Dropped, upstream.
+  * rules: Force building with python2.
+  * server.install: Updated.
+  * debian/.gitignore: Ignore d/control.
+  * rules: If git is installed, revert po/ on clean.
+  * server.dirs: Add missing directories, fix some permissions in
+    postinst.
+  * control.server: Bump dogtag dependencies to 10.6.0~.
+  * control.server: Drop mod-nss from Depends, mod_ssl is used instead.
+  * enable-mod-nss-during-setup.diff: Dropped, not needed anymore.
+  * server.postinst/postrm: Enable/disable mod_ssl.
+  * control: Bump 389-ds-base dependency.
+  * rules: Modify python scripts to use python2.
+  * fix-paths.diff: Add some paths to platform data.
+  * hack-tomcat-race.diff: Restarting pki-tomcatd takes time, and renew_ca_cert
+    does that several times in a row, so wait for 80s before starting migrating
+    profiles to ldap to make sure the instance is up.
+  * fix-apache-ssl-setup.diff: Fix mod_ssl setup.
+  * hack-duplicate-cert-directive.diff: Delete a duplicate
+    SSLCertificateFile directive until upstream is fixed.
+  * server.postinst: Enable default-ssl site.
+  * control: Depend on chrony instead of ntp.
+  * fix-paths.diff: Add CHRONY_CONF.
+  * python-ipaserver.install: Updated after dropping NTP.
+  * fix-version.diff: Append +git to prerelease tag, don't require git.
+  * pydist_overrides: Added.
+  * rules: Update clean target.
+  * control: Bump depends on bind9.
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Thu, 12 Apr 2018 14:01:56 +0300
+
+freeipa (4.6.3-1) unstable; urgency=medium
+
+  * New upstream release.
+  * support-kdb-dal-7.0.diff: Dropped, upstream.
+  * tests: Force hostname as 'autopkgtest' if the system didn't have
+    one.
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Fri, 02 Feb 2018 17:27:41 +0200
+
+freeipa (4.6.2-4) unstable; urgency=medium
+
+  * client.postinst: Migrate from old nssdb only if it exists.
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Tue, 30 Jan 2018 17:42:08 +0200
+
+freeipa (4.6.2-3) unstable; urgency=medium
+
+  * tests: Add some debug info, and fail properly.
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Mon, 29 Jan 2018 13:17:25 +0200
+
+freeipa (4.6.2-2) unstable; urgency=medium
+
+  * server.postinst: Fix output redirection.
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Sat, 20 Jan 2018 21:33:26 +0200
+
+freeipa (4.6.2-1) unstable; urgency=medium
+
+  * New upstream release.
+    - Remove upstreamed patches:
+      add-debian-platform.diff,
+      ipa-kdb-support-dal-version-5-and-6.diff,
+      purge-firefox-extension.diff,
+      fix-ipa-otpd-install.diff,
+      fix-ipa-otpd-service.diff,
+      purge-firefox-extension.diff,
+      prefix.patch,
+      fix-kdcproxy-path.diff,
+      fix-is-running.diff,
+      fix-pkcs11-helper.diff,
+      fix-dnssec-services.diff
+    - Remove obsolete patches: fix-memcached.diff,
+      fix-oddjobs.diff,
+      fix-kdcproxy-paths.diff
+    - Refresh rest of the patches
+  * control et al: Memcached is not used anymore.
+  * control, server.install: Depend on gssproxy.
+  * control: Build-depend on python-jinja2, add CSR files to python-
+    ipaclient.
+  * *.install: Updated.
+  * client.postinst: Fix update_ipa_nssdb import.
+  * rules, autoreconf: Refactor the build to match current upstream,
+    drop d/autoreconf.
+  * local-options: Ignore some files not on tarballs.
+  * rules: Migrate to dh_missing.
+  * Drop server tmpfile, ship upstream one, and create ipaapi/kdcproxy
+    users/groups on install and add www-data to ipaapi group.
+  * control: Add python-sss to python-ipaserver depends.
+  * rules: Disable building on a builddirectory, it's broken upstream
+    for now.
+  * control: Drop libcurl4-nss-dev from build-depends, bump libkrb5-dev
+    build-dependency.
+  * control: Bump dependency on bind9 and bind9-dyndb-ldap.
+  * control: add libapache2-mod-lookup-identity to server dependencies,
+    enable/disable it in postinst/postrm.
+  * control: Depend on newer custodia, move dep on python-custodia to
+    python-ipaserver.
+  * control: Add python-sss to client depends.
+  * Add support for krb 1.16. (Closes: #887814)
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Sat, 20 Jan 2018 12:41:28 +0200
+
+freeipa (4.4.4-4) unstable; urgency=medium
+
+  [ Timo Aaltonen ]
+  * fix-opendnssec-setup.diff: Use /usr/sbin prefix for ods binaries.
+  * samba-4.7-fix-*: Add backported commits to allow building against
+    samba 4.7. (Closes: #880841)
+
+  [ Steve Langasek ]
+  * Fix autopkgtest to be robust in the face of changed iproute2 output.
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Sat, 16 Dec 2017 09:15:37 +0200
+
+freeipa (4.4.4-3) unstable; urgency=medium
+
+  * fix-opendnssec-setup.diff: Fix a typo. (Closes: #878095)
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Mon, 09 Oct 2017 23:51:56 +0300
+
+freeipa (4.4.4-2) unstable; urgency=medium
+
+  * control: Add a dependency on fonts-open-sans. (LP: #1656236)
+  * fix-opendnssec-install.diff: Updated for opendnssec 2.1.x. (LP:
+    #1703836)
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Mon, 09 Oct 2017 10:41:55 +0300
+
+freeipa (4.4.4-1) unstable; urgency=medium
+
+  * Upload to unstable. (Closes: #862846)
+  * New upstream release.
+    - CVE-2017-2590
+    - ipa-kdb-support-dal-version-5-and-6.diff: Dropped, upstream.
+    - purge-firefox-extension.diff: Refreshed.
+  * fix-is-running.diff: Add a third argument to is_running() in
+    ipaplatform/debian/services.py. (Closes: #856533)
+  * fix-kdcproxy-path.diff: Update debian/paths.py to use correct path
+    for ipa-httpd-kdcproxy.
+  * client.dirs: Ship /etc/krb5.conf.d, because not having that breaks
+    the installer when krb5.conf tries to include that.
+  * copyright, watch: Update source/release location.
+  * control, ipaserver: Move adtrustinstance python files to python-
+    ipaserver, and add samba-common to python-ipaserver depends so that
+    uninstall works.
+  * fix-pkcs11-helper.diff: Fix ipa-dnskeysyncd setup which was broken
+    by softhsm 2.2.
+  * fix-opendnssec-setup.diff: Opendnssec 2.0.x broke DNSSEC setup, fix
+    it.
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Wed, 17 May 2017 21:19:22 +0300
+
+freeipa (4.4.3-3) experimental; urgency=medium
+
+  * client.postinst: Fix logfile location.
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Thu, 16 Feb 2017 11:26:08 +0200
+
+freeipa (4.4.3-2) experimental; urgency=medium
+
+  * control: Fix python-ipatests to depend on python-sss instead of
+    python-sssdconfig.
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Sat, 28 Jan 2017 00:15:53 +0200
+
+freeipa (4.4.3-1) experimental; urgency=medium
+
+  * New upstream release. (Closes: #848762)
+  * configure-apache-from-installer.diff: Dropped, upstream.
+  * fix-cve-2016-5404.diff: Dropped, upstream.
+  * patches: Refreshed.
+  * work-around-apache-fail.diff: Dropped, apache supports systemd now
+    so this should not be needed.
+  * watch: Use https url.
+  * client.postinst: Use update_ipa_nssdb(), which also removes remnants
+    from /etc/pki/nssdb.
+  * control: Bump depends on slapi-nis to 0.56.1.
+  * control: Add python-custodia and python-requests to ipalib depends.
+  * control: Use python-netifaces instead of iproute.
+  * control: Add python-sssdconfig to python-ipatests depends.
+  * control: Bump depends on 389-ds-base to 1.3.5.6, upstream #5396
+    #2008.
+  * control: Bump bind9-dyndb-ldap depends to 10, upstream #2008.
+  * control: Add python-libsss-nss-idmap to build-depends.
+  * control: Bump depends on sssd to 1.14.0.
+  * install: Updated.
+  * platform:
+    - drop variables that were commented out
+    - add some comments to tasks.py
+    - migrate some services to use systemd
+    - add & update some paths
+    - add some stub services (LP: #1653245)
+  * control: Add krb5-otp to server depends. (LP: #1640732)
+  * control: Demote ntp to Recommends so that lxc containers can be
+    enrolled without it. (LP: #1630911)
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Sat, 14 Jan 2017 15:29:25 +0200
+
+freeipa (4.3.2-5) unstable; urgency=medium
+
+  * fix-cve-2016-5404.diff: Fix permission check bypass (Closes: #835131)
+    - CVE-2016-5404
+  * ipa-kdb-support-dal-version-5-and-6.diff: Support mit-krb5 1.15.
+    (Closes: #844114)
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Sat, 03 Dec 2016 01:02:40 +0200
+
+freeipa (4.3.2-4) unstable; urgency=medium
+
+  * freeipa-client.post*: Use /var/log/ipaclient-upgrade.log instead of
+    ipaupgrade.log, and remove it on purge. (Closes: #842071)
+  * control: Bump dependency on libapache2-mod-auth-gssapi to verify
+    upstream bug #5653 is resolved.
+  * platform: Add Debian mapping for rpcgssd and rpcidmapd service
+    files. (LP: #1645201)
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Thu, 01 Dec 2016 08:12:27 +0200
+
+freeipa (4.3.2-3) unstable; urgency=medium
+
+  * rules: Add a check to override_dh_fixperms so that chmod is not run
+    on arch-indep build where the targets don't exist. (Closes: #839844)
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Thu, 06 Oct 2016 01:22:13 +0300
+
+freeipa (4.3.2-2) unstable; urgency=medium
+
+  * copyright: Since ffb9a09a0d all original code should be GPL-3+, so
+    drop some exceptions.
+  * control: Add libnss-sss, libpam-sss and libsss-sudo to client depends
+    to ensure they get installed. (LP: #1600513)
+  * fix-ipa-otpd-service.diff: Use correct path for ipa-otpd. (LP:
+    #1628884)
+  * add-debian-platform.diff: Fix libsofthsm2.so install path.
+  * control: Bump dep on softhsm2 due to changed lib install path.
+  * tests: Add simple autopkgtest to check that ipa-server-install
+    works.
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Wed, 05 Oct 2016 00:35:51 +0300
+
+freeipa (4.3.2-1) experimental; urgency=medium
+
+  * New upstream release.
+  * copyright, missing-sources, README.source: Exclude minified javascript
+    that the runtime does not need. Add unminified versions of others,
+    update copyright to match. (Closes: #787593)
+  * source/lintian-overrides: Document minified javascript issues.
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Wed, 14 Sep 2016 13:03:54 +0300
+
+freeipa (4.3.1-2) experimental; urgency=medium
+
+  * control: python-ipalib can be arch:all now.
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Mon, 25 Jul 2016 22:22:52 +0300
+
+freeipa (4.3.1-1) unstable; urgency=medium
+
+  * New upstream release. (Closes: #781607, #786411) (LP: #1449304)
+    - drop no-test-lang.diff, obsolete
+  * fix-match-hostname.diff, control: Drop the patch and python-openssl
+    deps, not needed anymore
+  * rules, platform, server.dirs, server.install:
+    Add support for DNSSEC.
+  * control, rules: Add support for kdcproxy.
+  * control, server: Migrate to mod-auth-gssapi.
+  * control, rules, fix-ipa-conf.diff: Add support for custodia.
+  * control:
+    - Add python-cryptography to build-deps and python-freeipa deps.
+    - Add libp11-kit-dev to build-deps, p11-kit to server deps.
+    - Depend on python-gssapi instead of python-kerberos/-krbV.
+    - Add libini-config-dev and python-dbus to build-deps, replace wget
+      with curl.
+    - Bump libkrb5-dev build-dep.
+    - Add pki-base to build-deps and pki-kra to server deps, bump pki-ca
+      version.
+    - Drop python-m2crypto from deps, obsolete.
+    - Bump sssd deps to 1.13.1.
+    - Add python-six to build-deps and python-freeipa deps.
+    - Split python stuff from server, client, tests to python-
+      ipa{server,client,tests}, rename python-freeipa to match and move
+      translations to freeipa-common. Mark them Arch:all where possible,
+      and add Breaks/Replaces.
+    - Add oddjob to server and oddjob-mkhomedir to client deps.
+    - Add python-setuptools to python-ipalib deps.
+    - Bump 389-ds-base* deps.
+    - Bump server and python-ipaserver dependency on python-ldap to 2.4.22
+      to fix a bug on ipa-server-upgrade.
+    - Add pki-tools to python-ipaserver deps.
+    - Add zip to python-ipaserver depends.
+    - Add python-systemd to server depends.
+    - Add opendnssec to freeipa-server-dns depends.
+    - Add python-cffi to python-ipalib depends.
+    - Bump dep on bind9-dyndb-ldap.
+    - Bump certmonger dependency to version that has helpers in the correct
+      place.
+  * patches:
+    - prefix.patch: Fix ipalib install too.
+    - Drop bits of platform.diff and other patches that are now upstream.
+    - fix-kdcproxy-paths.diff: Fix paths in kdcproxy configs.
+    - fix-oddjobs.diff: Fix paths and uids in oddjob configs.
+    - fix-replicainstall.diff: Use ldap instead of ldaps for conncheck.
+    - fix-dnssec-services.diff: Debianize ipa-dnskeysyncd & ipa-ods-
+      exporter units.
+    - create-sysconfig-ods.diff: Create an empty file for opendnssec
+      daemons, until opendnssec itself is fixed.
+    - purge-firefox-extension.diff: Clean obsolete kerberosauth.xpi.
+    - enable-mod-nss-during-setup.diff: Split from platform.diff, call
+      a2enmod/a2dismod from httpinstance.py.
+    - fix-memcached.diff: Split from platform.diff, debianize memcached
+      conf & unit.
+    - hack-libarch.diff: Don't use fedora libpaths.
+  * add-debian-platform.diff:
+    - Update paths.py to include all variables, comment out ones we don't
+      modify.
+    - Use systemwide certificate store; put ipa-ca.crt in
+      /usr/local/share/ca-certificates, and run update-ca-certificates
+    - Map smb service to smbd (LP: #1543230)
+    - Don't ship /var/cache/bind/data, fix named.conf a bit.
+    - Use DebianNoService() for dbus. (LP: #1564981)
+    - Add more constants
+  * Split freeipa-server-dns from freeipa-server, add -dns to -server
+    Recommends.
+  * server.postinst: Use ipa-server-upgrade.
+  * admintools: Use the new location for bash completions.
+  * rules: Remove obsolete configure.jar, preferences.html.
+  * platform: Fix ipautil.run stdout handling, add support for systemd.
+  * server.postinst, tmpfile: Create state directories for
+    mod_auth_gssapi.
+  * rules, server.install: Install scripts under /usr/lib instead of
+    multiarch path to avoid hacking the code too much.
+  * fix-ipa-otpd-install.diff, rules, server.install: Put ipa-otpd in
+    /usr/lib/ipa instead of directly under multiarch lib path.
+  * control, server*.install: Move dirsrv plugins from server-trust-ad
+    to server, needed on upgrades even if trust-ad isn't set up.
+  * server: Enable mod_proxy_ajp and mod_proxy_http on postinst, disable
+    on postrm.
+  * rules: Add SKIP_API_VERSION_CHECK, and adjust directories to clean.
+  * rules: Don't enable systemd units on install.
+  * client: Don't create /etc/pki/nssdb on postinst, it's not used
+    anymore.
+  * platform.diff, rules, server.install: Drop generate-rndc-key.sh, bind
+    already generates the keyfile.
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Mon, 18 Apr 2016 17:40:32 +0300
+
+freeipa (4.1.4-1) experimental; urgency=medium
+
+  * New upstream release. (LP: #1492226)
+    - Refresh patches
+    - platform-support.diff: Added NAMED_VAR_DIR.
+    - fix-bind-conf.diff: Dropped, obsolete with above.
+    - disable-dnssec-support.patch: Disable DNSSEC-support as we're
+      missing the dependencies for now.
+  * control: Add python-usb to build-depends and to python-freeipa
+    depends.
+  * control: Bump SSSD dependencies.
+  * control: Add libsofthsm2-dev to build-depends and softhsm2 to server
+    depends.
+  * freeipa-{server,client}.install: Add new files.
+  * control: Bump Depends on slapi-nis for CVE fixes.
+  * control: Bump 389-ds-base, pki-ca depends.
+  * control: Drop dogtag-pki-server-theme from server depends, it's not
+    needed.
+  * control: Server needs newer python-ldap, bump build-dep too.
+  * control: Bump certmonger depends.
+  * control: Bump python-nss depends.
+  * freeipa-client: Add /etc/ipa/nssdb, rework /etc/pki/nssdb handling.
+  * platform: Add DebianNamedService.
+  * platform, disable-dnssec-support.patch: Fix named.conf template.
+  * server.postinst: Run ipa-ldap-updater and ipa-upgradeconfig on
+    postinst.
+  * Revert DNSSEC changes to schema and ACI, makes upgrade tools fail.
+  * server.postrm: Clean logs on purge and disable apache modules on
+    remove/purge.
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Fri, 25 Sep 2015 14:07:40 +0300
+
+freeipa (4.0.5-6) unstable; urgency=medium
+
+  * control Add gnupg-agent to python-freeipa depends, and change gnupg
+    to gnupg2. (LP: #1492184)
+  * Rebuild against current krb5, there was an abi break which broke at
+    least the setup phase.
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Thu, 24 Sep 2015 23:22:24 +0300
+
+freeipa (4.0.5-5) unstable; urgency=medium
+
+  * control: Drop selinux-policy-dev from build-depends, not needed
+    anymore.
+  * client.dirs,postrm: Drop removing /etc/pki/nssdb from postrm and let
+    dpkg handle it. (Closes: #781114)
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Thu, 09 Apr 2015 17:16:37 +0300
+
+freeipa (4.0.5-4) unstable; urgency=medium
+
+  * control: Fix freeipa-tests depends.
+  * control: Add systemd-sysv to server depends. (Closes: #780386)
+  * freeipa-client.postrm: Purge /etc/pki if empty. (Closes: #781114)
+  * add-a-clear-openssl-exception.diff: Add a clear OpenSSL exception.
+    (Closes: #772136)
+  * control: Add systemd to build-depends.
+  * dont-check-for-systemd-pc.diff: Dropped, not needed anymore.
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Thu, 02 Apr 2015 10:53:55 +0300
+
+freeipa (4.0.5-3) unstable; urgency=medium
+
+  * rules: Set JAVA_STACK_SIZE to hopefully avoid FTBFS on exotic archs.
+  * freeipa-client.postrm: Remove nssdb files on purge. (Closes:
+    #775387)
+  * freeipa-client.postinst: Fix bashism with echo. (Closes: #772242)
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Wed, 04 Mar 2015 14:51:35 +0200
+
+freeipa (4.0.5-2) unstable; urgency=medium
+
+  * Team upload.
+  * Let python-freeipa depend on python-pyasn1, because pyasn1 is imported
+    by ipalib/pkcs10.py and ipalib/plugins/cert.py.
+  * debian/copyright: Drop unused PD license section
+  * debian/copyright: Fix paths of Javascript files
+
+ -- Benjamin Drung <benjamin.drung@profitbricks.com>  Mon, 24 Nov 2014 12:32:36 +0100
+
+freeipa (4.0.5-1) unstable; urgency=medium
+
+  * New upstream release
+    - Fix CVE-2014-7828. (Closes: #768294)
+  * control: Update my email address.
+  * fix-bind-conf.diff, add-debian-platform.diff: Fix bind config
+    template to use Debian specific paths, and replace named.conf not
+    named.conf.local. (Closes: #768122)
+  * rules, -server.postinst: Create /var/cache/bind/data owned by bind
+    user.
+  * rules: Fix /var/lib/ipa/backup permissions.
+  * Add non-standard-dir-perm to server lintian overrides.
+  * copyright: Fix a typo.
+  * control: Bump dependency on bind9-dyndb-ldap to 6.0-4~.
+  * control: Move dependency on python-qrcode and python-yubico from
+    server to python-freeipa and drop python-selinux which belongs to
+    pki-server.
+  * control: Relax libxmlrpc-core-c3-dev buil-dep and 389-ds-base dep
+    for easier backporting.
+  * control: Add python-dateutils to server, and python-dbus and python-
+    memcache to python-freeipa dependencies. (Closes: #768187)
+  * platform: Handle /etc/default/nfs-common and /etc/default/autofs,
+    drop NSS_DB_DIR since it's inherited already. (Closes: #769037)
+  * control: Bump policy to 3.9.6, no changes.
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Tue, 11 Nov 2014 10:38:52 +0200
+
+freeipa (4.0.4-2) unstable; urgency=medium
+
+  * control: Add python-qrcode, python-selinux, python-yubico
+    to freeipa-server dependencies. (Closes: #767427)
+  * freeipa-server.postinst: Enable mod_authz_user and mod_deflate too,
+    but since they should be part of the default apache2 install, don't
+    disable them on uninstall like the other modules. (Closes: #767425)
+  * control: Bump server dependency on -mod-nss to 1.0.10-2 which
+    doesn't enable the module by default.
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Fri, 31 Oct 2014 11:36:51 +0200
+
+freeipa (4.0.4-1) unstable; urgency=medium
+
+  * Initial release (Closes: #734703)
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Sat, 25 Oct 2014 02:43:59 +0300

debian/control

@@ -0,0 +1,205 @@
+Source: freeipa
+Section: net
+Priority: optional
+Maintainer: Debian FreeIPA Team <pkg-freeipa-devel@alioth-lists.debian.net>
+Uploaders: Timo Aaltonen <tjaalton@debian.org>
+Standards-Version: 4.5.0
+Vcs-Git: https://salsa.debian.org/freeipa-team/freeipa.git
+Vcs-Browser: https://salsa.debian.org/freeipa-team/freeipa
+Homepage: http://www.freeipa.org
+Build-Depends:
+ check,
+ debhelper-compat (= 13),
+ dh-python,
+ gettext,
+ krb5-user,
+ libcmocka-dev,
+ libcurl4-openssl-dev,
+ libini-config-dev,
+ libjansson-dev,
+ libkrad-dev,
+ libkrb5-dev (>= 1.18),
+ libldap2-dev,
+ libnspr4-dev,
+ libpopt-dev,
+ librpm-dev,
+ libsasl2-dev,
+ libssl-dev,
+ libtalloc-dev,
+ python3-all-dev,
+ python3-cryptography,
+ python3-dbus,
+ python3-dnspython (>= 1.11.1),
+ python3-gssapi,
+ python3-jinja2,
+ python3-kdcproxy,
+ python3-ldap (>= 3.1),
+ python3-lesscpy,
+ python3-libipa-hbac,
+ python3-libsss-nss-idmap,
+ python3-lxml,
+ python3-netaddr,
+ python3-netifaces (>= 0.10.4),
+ python3-polib,
+ python3-pyasn1,
+ python3-qrcode (>= 5.0.0),
+ python3-setuptools,
+ python3-six,
+ python3-sphinx,
+ python3-sss (>= 1.14.0),
+ python3-usb (>= 1.0.0~b2),
+ python3-yubico,
+ systemd-dev,
+ uuid-dev,
+
+Package: freeipa-common
+Architecture: all
+Depends:
+ ${misc:Depends},
+Multi-Arch: foreign
+Description: FreeIPA centralized identity framework -- common files
+ FreeIPA is an integrated solution to provide centrally managed Identity
+ (machine, user, virtual machines, groups, authentication credentials), Policy
+ (configuration settings, access control information) and Audit (events,
+ logs, analysis thereof).
+ .
+ This package includes common files.
+
+Package: freeipa-client
+Architecture: any
+Depends:
+ bind9-utils,
+ certmonger (>= 0.79.14),
+ curl,
+ bind9-dnsutils,
+ freeipa-common (= ${source:Version}),
+ krb5-user,
+ libnss3-tools,
+ libnss-sss,
+ libpam-sss,
+ libsasl2-modules-gssapi-mit,
+ libsss-sudo,
+ oddjob-mkhomedir,
+ python3-dnspython,
+ python3-ipaclient (= ${source:Version}),
+ python3-gssapi,
+ python3-ldap,
+ python3-sss,
+ sssd (>= 2.8.0),
+ ${misc:Depends},
+ ${python3:Depends},
+ ${shlibs:Depends}
+Recommends:
+ chrony,
+ sssd-passkey,
+Suggests:
+ libnss-myhostname,
+ libpam-krb5,
+Description: FreeIPA centralized identity framework -- client
+ FreeIPA is an integrated solution to provide centrally managed Identity
+ (machine, user, virtual machines, groups, authentication credentials), Policy
+ (configuration settings, access control information) and Audit (events,
+ logs, analysis thereof).
+ .
+ This is the client package.
+
+Package: freeipa-client-epn
+Architecture: amd64 arm64 armhf i386 mips mips64el mipsel ppc64 ppc64el s390x
+Depends:
+ freeipa-client (= ${binary:Version}),
+ ${misc:Depends},
+ ${python3:Depends},
+ ${shlibs:Depends}
+Breaks: freeipa-server (<< 4.8.10-2)
+Replaces: freeipa-server (<< 4.8.10-2)
+Description: FreeIPA centralized identity framework -- tools for configuring Expiring Password Notification
+ FreeIPA is an integrated solution to provide centrally managed Identity
+ (machine, user, virtual machines, groups, authentication credentials), Policy
+ (configuration settings, access control information) and Audit (events,
+ logs, analysis thereof).
+ .
+ This package provides a service to collect and send expiring password
+ notifications via email (SMTP).
+
+Package: freeipa-client-samba
+Architecture: any
+Depends:
+ cifs-utils,
+ freeipa-client (= ${binary:Version}),
+ python3-samba,
+ samba-common-bin,
+ smbclient,
+ tdb-tools,
+ winbind,
+ ${misc:Depends},
+ ${python3:Depends},
+Multi-Arch: same
+Description: FreeIPA centralized identity framework -- Samba client
+ FreeIPA is an integrated solution to provide centrally managed Identity
+ (machine, user, virtual machines, groups, authentication credentials), Policy
+ (configuration settings, access control information) and Audit (events,
+ logs, analysis thereof).
+ .
+ This package provides command-line tools to deploy Samba domain member
+ on the machine enrolled into a FreeIPA environment.
+
+Package: python3-ipaclient
+Architecture: all
+Section: python
+Breaks: freeipa-client (<< 4.3.0-1)
+Replaces: freeipa-client (<< 4.3.0-1)
+Depends:
+ freeipa-common (= ${binary:Version}),
+ python3-augeas,
+ python3-dnspython,
+ python3-ipalib (>= ${source:Version}),
+ python3-jinja2,
+ ${misc:Depends},
+ ${python3:Depends},
+Description: FreeIPA centralized identity framework -- Python3 modules for ipaclient
+ FreeIPA is an integrated solution to provide centrally managed Identity
+ (machine, user, virtual machines, groups, authentication credentials), Policy
+ (configuration settings, access control information) and Audit (events,
+ logs, analysis thereof).
+ .
+ This Python3 module is used by FreeIPA client.
+
+Package: python3-ipalib
+Architecture: all
+Section: python
+Depends:
+ freeipa-common (= ${source:Version}),
+ gpg,
+ gpg-agent,
+ keyutils,
+ python3-cffi,
+ python3-cryptography,
+ python3-dbus,
+ python3-dnspython,
+ python3-gssapi,
+ python3-ifaddr,
+ python3-ldap,
+ python3-libipa-hbac,
+ python3-lxml,
+ python3-netaddr,
+ python3-netifaces (>= 0.10.4),
+ python3-pyasn1,
+ python3-qrcode (>= 5.0.0),
+ python3-requests,
+ python3-setuptools,
+ python3-six,
+ python3-usb (>= 1.0.0~b2),
+ python3-yubico,
+ systemd,
+ ${misc:Depends},
+ ${python3:Depends},
+ ${shlibs:Depends},
+ ${lib:Depends},
+Description: FreeIPA centralized identity framework -- shared Python3 modules
+ FreeIPA is an integrated solution to provide centrally managed Identity
+ (machine, user, virtual machines, groups, authentication credentials), Policy
+ (configuration settings, access control information) and Audit (events,
+ logs, analysis thereof).
+ .
+ This Python3 module is used by other FreeIPA packages.
+

debian/control.common

@@ -0,0 +1,152 @@
+
+Package: freeipa-common
+Architecture: all
+Depends:
+ ${misc:Depends},
+Multi-Arch: foreign
+Description: FreeIPA centralized identity framework -- common files
+ FreeIPA is an integrated solution to provide centrally managed Identity
+ (machine, user, virtual machines, groups, authentication credentials), Policy
+ (configuration settings, access control information) and Audit (events,
+ logs, analysis thereof).
+ .
+ This package includes common files.
+
+Package: freeipa-client
+Architecture: any
+Depends:
+ bind9-utils,
+ certmonger (>= 0.79.14),
+ curl,
+ bind9-dnsutils,
+ freeipa-common (= ${source:Version}),
+ krb5-user,
+ libnss3-tools,
+ libnss-sss,
+ libpam-sss,
+ libsasl2-modules-gssapi-mit,
+ libsss-sudo,
+ oddjob-mkhomedir,
+ python3-dnspython,
+ python3-ipaclient (= ${source:Version}),
+ python3-gssapi,
+ python3-ldap,
+ python3-sss,
+ sssd (>= 2.8.0),
+ ${misc:Depends},
+ ${python3:Depends},
+ ${shlibs:Depends}
+Recommends:
+ chrony,
+ sssd-passkey,
+Suggests:
+ libnss-myhostname,
+ libpam-krb5,
+Description: FreeIPA centralized identity framework -- client
+ FreeIPA is an integrated solution to provide centrally managed Identity
+ (machine, user, virtual machines, groups, authentication credentials), Policy
+ (configuration settings, access control information) and Audit (events,
+ logs, analysis thereof).
+ .
+ This is the client package.
+
+Package: freeipa-client-epn
+Architecture: amd64 arm64 armhf i386 mips mips64el mipsel ppc64 ppc64el s390x
+Depends:
+ freeipa-client (= ${binary:Version}),
+ ${misc:Depends},
+ ${python3:Depends},
+ ${shlibs:Depends}
+Breaks: freeipa-server (<< 4.8.10-2)
+Replaces: freeipa-server (<< 4.8.10-2)
+Description: FreeIPA centralized identity framework -- tools for configuring Expiring Password Notification
+ FreeIPA is an integrated solution to provide centrally managed Identity
+ (machine, user, virtual machines, groups, authentication credentials), Policy
+ (configuration settings, access control information) and Audit (events,
+ logs, analysis thereof).
+ .
+ This package provides a service to collect and send expiring password
+ notifications via email (SMTP).
+
+Package: freeipa-client-samba
+Architecture: any
+Depends:
+ cifs-utils,
+ freeipa-client (= ${binary:Version}),
+ python3-samba,
+ samba-common-bin,
+ smbclient,
+ tdb-tools,
+ winbind,
+ ${misc:Depends},
+ ${python3:Depends},
+Multi-Arch: same
+Description: FreeIPA centralized identity framework -- Samba client
+ FreeIPA is an integrated solution to provide centrally managed Identity
+ (machine, user, virtual machines, groups, authentication credentials), Policy
+ (configuration settings, access control information) and Audit (events,
+ logs, analysis thereof).
+ .
+ This package provides command-line tools to deploy Samba domain member
+ on the machine enrolled into a FreeIPA environment.
+
+Package: python3-ipaclient
+Architecture: all
+Section: python
+Breaks: freeipa-client (<< 4.3.0-1)
+Replaces: freeipa-client (<< 4.3.0-1)
+Depends:
+ freeipa-common (= ${binary:Version}),
+ python3-augeas,
+ python3-dnspython,
+ python3-ipalib (>= ${source:Version}),
+ python3-jinja2,
+ ${misc:Depends},
+ ${python3:Depends},
+Description: FreeIPA centralized identity framework -- Python3 modules for ipaclient
+ FreeIPA is an integrated solution to provide centrally managed Identity
+ (machine, user, virtual machines, groups, authentication credentials), Policy
+ (configuration settings, access control information) and Audit (events,
+ logs, analysis thereof).
+ .
+ This Python3 module is used by FreeIPA client.
+
+Package: python3-ipalib
+Architecture: all
+Section: python
+Depends:
+ freeipa-common (= ${source:Version}),
+ gpg,
+ gpg-agent,
+ keyutils,
+ python3-cffi,
+ python3-cryptography,
+ python3-dbus,
+ python3-dnspython,
+ python3-gssapi,
+ python3-ifaddr,
+ python3-ldap,
+ python3-libipa-hbac,
+ python3-lxml,
+ python3-netaddr,
+ python3-netifaces (>= 0.10.4),
+ python3-pyasn1,
+ python3-qrcode (>= 5.0.0),
+ python3-requests,
+ python3-setuptools,
+ python3-six,
+ python3-usb (>= 1.0.0~b2),
+ python3-yubico,
+ systemd,
+ ${misc:Depends},
+ ${python3:Depends},
+ ${shlibs:Depends},
+ ${lib:Depends},
+Description: FreeIPA centralized identity framework -- shared Python3 modules
+ FreeIPA is an integrated solution to provide centrally managed Identity
+ (machine, user, virtual machines, groups, authentication credentials), Policy
+ (configuration settings, access control information) and Audit (events,
+ logs, analysis thereof).
+ .
+ This Python3 module is used by other FreeIPA packages.
+

debian/control.server

@@ -0,0 +1,179 @@
+
+Package: freeipa-server
+Architecture: amd64 arm64 armhf i386 mips mips64el mipsel ppc64 ppc64el s390x
+Breaks: freeipa-server-trust-ad (<< 4.3.0-1)
+Replaces: freeipa-server-trust-ad (<< 4.3.0-1)
+Depends:
+ 389-ds-base (>= 1.4.4.16),
+ acl,
+ adduser,
+ apache2 (>= 2.4.41-4ubuntu2),
+ certmonger (>= 0.79.14),
+ chrony,
+ fonts-font-awesome,
+ fonts-open-sans,
+ freeipa-client (= ${binary:Version}),
+ freeipa-common (= ${source:Version}),
+ gssproxy (>= 0.8.2-2),
+ krb5-admin-server,
+ krb5-kdc (>= 1.18),
+ krb5-kdc-ldap,
+ krb5-otp,
+ krb5-pkinit,
+ ldap-utils,
+ libapache2-mod-auth-gssapi (>= 1.5.0),
+ libapache2-mod-lookup-identity (>= 1.0.0),
+ libapache2-mod-wsgi-py3,
+ libjs-dojo-core,
+ libjs-jquery,
+ libjs-scriptaculous,
+ libnss3-tools,
+ libsasl2-modules-gssapi-mit,
+ oddjob (>= 0.34.3-2),
+ p11-kit,
+ pki-ca (>= 10.10.6~),
+ pki-kra (>= 10.10.6~),
+ python3-dateutil,
+ python3-ipaserver (= ${source:Version}),
+ python3-gssapi,
+ python3-ldap (>= 2.4.22),
+ python3-systemd,
+ slapi-nis (>= 0.56.1),
+ ssl-cert,
+ sssd-dbus,
+ systemd-sysv,
+ ${misc:Depends},
+ ${python3:Depends},
+ ${shlibs:Depends}
+Recommends:
+ freeipa-server-dns,
+Description: FreeIPA centralized identity framework -- server
+ FreeIPA is an integrated solution to provide centrally managed Identity
+ (machine, user, virtual machines, groups, authentication credentials), Policy
+ (configuration settings, access control information) and Audit (events,
+ logs, analysis thereof).
+ .
+ This is the server package.
+
+Package: freeipa-server-dns
+Architecture: all
+Breaks: freeipa-server (<< 4.3.0-1)
+Replaces: freeipa-server (<< 4.3.0-1)
+Depends:
+ freeipa-server (>= ${source:Version}),
+ bind9 (>= 1:9.18.7),
+ bind9-dyndb-ldap (>= 11.4),
+ libengine-pkcs11-openssl,
+ opendnssec (>= 1:2.1.5),
+ softhsm2,
+ ${misc:Depends},
+ ${python3:Depends},
+ ${shlibs:Depends}
+Description: FreeIPA centralized identity framework -- IPA DNS integration
+ FreeIPA is an integrated solution to provide centrally managed Identity
+ (machine, user, virtual machines, groups, authentication credentials), Policy
+ (configuration settings, access control information) and Audit (events,
+ logs, analysis thereof).
+ .
+ This package adds DNS integration with BIND 9.
+
+Package: freeipa-server-trust-ad
+Architecture: amd64 arm64 armhf i386 mips mips64el mipsel ppc64 ppc64el s390x
+Depends:
+ freeipa-common (= ${source:Version}),
+ freeipa-server (= ${binary:Version}),
+ python3-ipaserver (= ${source:Version}),
+ python3-samba,
+ samba,
+ winbind,
+ ${misc:Depends},
+ ${python3:Depends},
+ ${shlibs:Depends}
+Multi-Arch: same
+Description: FreeIPA centralized identity framework -- AD trust installer
+ FreeIPA is an integrated solution to provide centrally managed Identity
+ (machine, user, virtual machines, groups, authentication credentials), Policy
+ (configuration settings, access control information) and Audit (events,
+ logs, analysis thereof).
+ .
+ Cross-realm trusts with Active Directory in IPA require working Samba 4
+ installation. This package is provided for convenience to install all required
+ dependencies at once.
+
+Package: freeipa-tests
+Architecture: all
+Depends:
+ python3-ipalib (>= ${source:Version}),
+ python3-ipatests (>= ${source:Version}),
+ python3-pytest,
+ ${misc:Depends},
+ ${python3:Depends}
+Recommends: python3-yaml
+Description: FreeIPA centralized identity framework -- tests
+ FreeIPA is an integrated solution to provide centrally managed Identity
+ (machine, user, virtual machines, groups, authentication credentials), Policy
+ (configuration settings, access control information) and Audit (events,
+ logs, analysis thereof).
+ .
+ This package contains tests that verify IPA functionality.
+
+Package: python3-ipaserver
+Architecture: all
+Section: python
+Breaks: freeipa-server (<< 4.3.0-1),
+ freeipa-server-trust-ad (<< 4.4.4-1),
+Replaces: freeipa-server (<< 4.3.0-1),
+ freeipa-server-trust-ad (<< 4.4.4-1),
+Depends:
+ freeipa-common (= ${binary:Version}),
+ pki-tools (>= 10.2.6-3),
+ python3-dbus,
+ python3-dnspython,
+ python3-gssapi,
+ python3-ipaclient (= ${binary:Version}),
+ python3-ipalib (>= ${source:Version}),
+ python3-jwcrypto,
+ python3-kdcproxy,
+ python3-ldap (>= 2.4.22),
+ python3-libsss-nss-idmap,
+ python3-pki-base,
+ python3-pyasn1,
+ python3-sss,
+ samba-common,
+ zip,
+ ${misc:Depends},
+ ${python3:Depends},
+Description: FreeIPA centralized identity framework -- Python3 modules for server
+ FreeIPA is an integrated solution to provide centrally managed Identity
+ (machine, user, virtual machines, groups, authentication credentials), Policy
+ (configuration settings, access control information) and Audit (events,
+ logs, analysis thereof).
+ .
+ This Python3 module is used by FreeIPA server.
+
+Package: python3-ipatests
+Architecture: all
+Section: python
+Breaks: freeipa-tests (<< 4.3.0-1)
+Replaces: freeipa-tests (<< 4.3.0-1)
+Depends:
+ libnss3-tools,
+ python3-ipalib (>= ${source:Version}),
+ python3-mock,
+ python3-paramiko,
+ python3-polib,
+ python3-pytest-multihost,
+ python3-pytest-sourceorder,
+ python3-sss,
+ xz-utils,
+ ${misc:Depends},
+ ${python3:Depends}
+Recommends: python3-yaml
+Description: FreeIPA centralized identity framework -- Python3 modules for tests
+ FreeIPA is an integrated solution to provide centrally managed Identity
+ (machine, user, virtual machines, groups, authentication credentials), Policy
+ (configuration settings, access control information) and Audit (events,
+ logs, analysis thereof).
+ .
+ This Python3 module is used by FreeIPA tests.
+

debian/control.server-bdeps

@@ -0,0 +1,14 @@
+ 389-ds-base-dev (>= 1.4.4.16),
+ libpwquality-dev,
+ libsss-idmap-dev,
+ libsss-certmap-dev,
+ libsss-nss-idmap-dev (>= 1.14.0),
+ libtevent-dev,
+ libunistring-dev,
+ libverto-dev,
+ nodejs [amd64 arm64 armhf i386 mips mips64el mipsel ppc64 ppc64el s390x],
+ pki-base (>= 10.10.6~),
+ python3-lesscpy,
+ python3-pkg-resources,
+ python3-rjsmin,
+ samba-dev,

debian/control.stub

@@ -0,0 +1,53 @@
+Source: freeipa
+Section: net
+Priority: optional
+Maintainer: Debian FreeIPA Team <pkg-freeipa-devel@alioth-lists.debian.net>
+Uploaders: Timo Aaltonen <tjaalton@debian.org>
+Standards-Version: 4.5.0
+Vcs-Git: https://salsa.debian.org/freeipa-team/freeipa.git
+Vcs-Browser: https://salsa.debian.org/freeipa-team/freeipa
+Homepage: http://www.freeipa.org
+Build-Depends:
+ check,
+ debhelper-compat (= 13),
+ dh-python,
+ gettext,
+ krb5-user,
+ libcmocka-dev,
+ libcurl4-openssl-dev,
+ libini-config-dev,
+ libjansson-dev,
+ libkrad-dev,
+ libkrb5-dev (>= 1.18),
+ libldap2-dev,
+ libnspr4-dev,
+ libpopt-dev,
+ librpm-dev,
+ libsasl2-dev,
+ libssl-dev,
+ libtalloc-dev,
+ python3-all-dev,
+ python3-cryptography,
+ python3-dbus,
+ python3-dnspython (>= 1.11.1),
+ python3-gssapi,
+ python3-jinja2,
+ python3-kdcproxy,
+ python3-ldap (>= 3.1),
+ python3-lesscpy,
+ python3-libipa-hbac,
+ python3-libsss-nss-idmap,
+ python3-lxml,
+ python3-netaddr,
+ python3-netifaces (>= 0.10.4),
+ python3-polib,
+ python3-pyasn1,
+ python3-qrcode (>= 5.0.0),
+ python3-setuptools,
+ python3-six,
+ python3-sphinx,
+ python3-sss (>= 1.14.0),
+ python3-usb (>= 1.0.0~b2),
+ python3-yubico,
+ systemd-dev,
+ uuid-dev,

debian/copyright

@@ -0,0 +1,332 @@
+Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
+Upstream-name: freeipa
+Source: http://releases.pagure.org/freeipa
+
+Files: *
+Copyright: 1999-2011 Red Hat, Inc.
+License: GPL-3+
+
+Files: debian/*
+Copyright: Michele Baldessari michele@pupazzo.org>
+           Timo Aaltonen <tjaalton@ubuntu.com>
+License: GPL-2+
+
+Files: daemons/ipa-slapi-plugins/*/*.c
+       daemons/ipa-slapi-plugins/*/*.h
+Copyright: 2005-2010 Red Hat, Inc.
+License: GPL-3+ with OpenSSL exception
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ .
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+ .
+ You should have received a copy of the GNU General Public License
+ along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ .
+ Additional permission under GPLv3 section 7:
+ .
+ In the following paragraph, "GPL" means the GNU General Public
+ License, version 3 or any later version, and "Non-GPL Code" means
+ code that is governed neither by the GPL nor a license
+ compatible with the GPL.
+ .
+ You may link the code of this Program with Non-GPL Code and convey
+ linked combinations including the two, provided that such Non-GPL
+ Code only links to the code of this Program through those well
+ defined interfaces identified in the file named EXCEPTION found in
+ the source code files (the "Approved Interfaces"). The files of
+ Non-GPL Code may instantiate templates or use macros or inline
+ functions from the Approved Interfaces without causing the resulting
+ work to be covered by the GPL. Only the copyright holders of this
+ Program may make changes or additions to the list of Approved
+ Interfaces.
+
+Files: install/ui/css/patternfly.css
+Copyright: Nicolas Gallagher
+           Jonathan Neal
+License: MIT
+
+Files: install/ui/src/libs/bootstrap.js
+       debian/missing-sources/bootstrap*.js
+Copyright: 2011-2014 Twitter, Inc.
+License: MIT
+
+Files: install/ui/src/libs/d3.js
+       debian/missing-sources/d3.js
+Copyright: 2010-2015, Michael Bostock
+License: BSD-3-clause
+
+Files: install/ui/src/libs/jquery.js
+       debian/missing-sources/jquery-2.0.3.js
+Copyright: 2005, 2013 jQuery Foundation, Inc.
+License: MIT
+
+Files: install/ui/src/libs/json2.js
+Copyright: None
+License: public-domain
+ Public Domain.
+
+Files: install/ui/src/libs/patternfly.js
+       debian/missing-sources/patternfly.js
+Copyright: 2013, Red Hat
+License: Apache-2.0
+
+Files: install/ui/src/libs/qrcode.js
+       debian/missing-sources/qrcode.js
+Copyright: 2012, Shim Sangmin
+License: MIT
+
+Files: install/ui/less/font-awesome/*
+Copyright: 2012-2013, Dave Gandy <drgandy@alum.mit.edu>
+License: MIT
+
+Files: install/ui/util/build/build.js
+       install/ui/build/dojo/dojo.js
+       debian/missing-sources/dojo/*
+Copyright: 2004-2012, The Dojo Foundation
+License: BSD-3-clause or AFL-2.1
+
+Files: install/ui/test/qunit.css install/ui/test/qunit.js
+Copyright: 2009, John Resig, Jörn Zaefferer
+           2008, Ariel Flesler
+License: MIT or GPL-2 or BSD-2-clause
+
+License: GPL-2
+ On Debian machines the full text of the GNU General Public License
+ version 2 can be found in the file /usr/share/common-licenses/GPL-2.
+
+License: GPL-2+
+ On Debian machines the full text of the GNU General Public License
+ version 2 can be found in the file /usr/share/common-licenses/GPL-2.
+
+License: GPL-3+
+ On Debian machines the full text of the GNU General Public License
+ version 3 can be found in the file /usr/share/common-licenses/GPL-3.
+
+License: BSD-2-clause
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions
+ are met:
+ .
+     * Redistributions of source code must retain the above
+       copyright notice, this list of conditions and the following
+       disclaimer.
+ .
+     * 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 HOLDER "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 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.
+
+License: BSD-3-clause
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+ .
+   * Redistributions of source code must retain the above copyright notice, this
+     list of conditions and the following disclaimer.
+   * 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.
+   * Neither the name of the Dojo Foundation nor the names of its contributors
+     may be used to endorse or promote products derived from this software
+     without specific prior written permission.
+ .
+ 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 OWNER 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.
+
+License: MIT
+ Permission is hereby granted, free of charge, to any person obtaining a copy of this software
+ and associated documentation files (the "Software"), to deal in the Software without
+ restriction, including without limitation the rights to use, copy, modify, merge, publish,
+ distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
+ Software is furnished to do so, subject to the following conditions:
+ .
+ The above copyright notice and this permission notice shall be included in all copies or
+ substantial portions of the Software.
+ .
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+License: AFL-2.1
+ This Academic Free License (the "License") applies to any original work of
+ authorship (the "Original Work") whose owner (the "Licensor") has placed the
+ following notice immediately following the copyright notice for the Original
+ Work:
+ .
+ Licensed under the Academic Free License version 2.1
+ .
+ 1) Grant of Copyright License. Licensor hereby grants You a world-wide,
+ royalty-free, non-exclusive, perpetual, sublicenseable license to do the
+ following:
+ .
+ a) to reproduce the Original Work in copies;
+ .
+ b) to prepare derivative works ("Derivative Works") based upon the Original
+ Work;
+ .
+ c) to distribute copies of the Original Work and Derivative Works to the
+ public;
+ .
+ d) to perform the Original Work publicly; and
+ .
+ e) to display the Original Work publicly.
+ .
+ 2) Grant of Patent License. Licensor hereby grants You a world-wide,
+ royalty-free, non-exclusive, perpetual, sublicenseable license, under patent
+ claims owned or controlled by the Licensor that are embodied in the Original
+ Work as furnished by the Licensor, to make, use, sell and offer for sale the
+ Original Work and Derivative Works.
+ .
+ 3) Grant of Source Code License. The term "Source Code" means the preferred
+ form of the Original Work for making modifications to it and all available
+ documentation describing how to modify the Original Work. Licensor hereby
+ agrees to provide a machine-readable copy of the Source Code of the Original
+ Work along with each copy of the Original Work that Licensor distributes.
+ Licensor reserves the right to satisfy this obligation by placing a
+ machine-readable copy of the Source Code in an information repository
+ reasonably calculated to permit inexpensive and convenient access by You for as
+ long as Licensor continues to distribute the Original Work, and by publishing
+ the address of that information repository in a notice immediately following
+ the copyright notice that applies to the Original Work.
+ .
+ 4) Exclusions From License Grant. Neither the names of Licensor, nor the names
+ of any contributors to the Original Work, nor any of their trademarks or
+ service marks, may be used to endorse or promote products derived from this
+ Original Work without express prior written permission of the Licensor. Nothing
+ in this License shall be deemed to grant any rights to trademarks, copyrights,
+ patents, trade secrets or any other intellectual property of Licensor except as
+ expressly stated herein. No patent license is granted to make, use, sell or
+ offer to sell embodiments of any patent claims other than the licensed claims
+ defined in Section 2. No right is granted to the trademarks of Licensor even if
+ such marks are included in the Original Work. Nothing in this License shall be
+ interpreted to prohibit Licensor from licensing under different terms from this
+ License any Original Work that Licensor otherwise would have a right to
+ license.
+ .
+ 5) This section intentionally omitted.
+ .
+ 6) Attribution Rights. You must retain, in the Source Code of any Derivative
+ Works that You create, all copyright, patent or trademark notices from the
+ Source Code of the Original Work, as well as any notices of licensing and any
+ descriptive text identified therein as an "Attribution Notice." You must cause
+ the Source Code for any Derivative Works that You create to carry a prominent
+ Attribution Notice reasonably calculated to inform recipients that You have
+ modified the Original Work.
+ .
+ 7) Warranty of Provenance and Disclaimer of Warranty. Licensor warrants that
+ the copyright in and to the Original Work and the patent rights granted herein
+ by Licensor are owned by the Licensor or are sublicensed to You under the terms
+ of this License with the permission of the contributor(s) of those copyrights
+ and patent rights. Except as expressly stated in the immediately proceeding
+ sentence, the Original Work is provided under this License on an "AS IS" BASIS
+ and WITHOUT WARRANTY, either express or implied, including, without limitation,
+ the warranties of NON-INFRINGEMENT, MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ PURPOSE. THE ENTIRE RISK AS TO THE QUALITY OF THE ORIGINAL WORK IS WITH YOU.
+ This DISCLAIMER OF WARRANTY constitutes an essential part of this License. No
+ license to Original Work is granted hereunder except under this disclaimer.
+ .
+ 8) Limitation of Liability. Under no circumstances and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise, shall the
+ Licensor be liable to any person for any direct, indirect, special, incidental,
+ or consequential damages of any character arising as a result of this License
+ or the use of the Original Work including, without limitation, damages for loss
+ of goodwill, work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses. This limitation of liability shall not
+ apply to liability for death or personal injury resulting from Licensor's
+ negligence to the extent applicable law prohibits such limitation. Some
+ jurisdictions do not allow the exclusion or limitation of incidental or
+ consequential damages, so this exclusion and limitation may not apply to You.
+ .
+ 9) Acceptance and Termination. If You distribute copies of the Original Work or
+ a Derivative Work, You must make a reasonable effort under the circumstances to
+ obtain the express assent of recipients to the terms of this License. Nothing
+ else but this License (or another written agreement between Licensor and You)
+ grants You permission to create Derivative Works based upon the Original Work
+ or to exercise any of the rights granted in Section 1 herein, and any attempt
+ to do so except under the terms of this License (or another written agreement
+ between Licensor and You) is expressly prohibited by U.S. copyright law, the
+ equivalent laws of other countries, and by international treaty. Therefore, by
+ exercising any of the rights granted to You in Section 1 herein, You indicate
+ Your acceptance of this License and all of its terms and conditions.
+ .
+ 10) Termination for Patent Action. This License shall terminate automatically
+ and You may no longer exercise any of the rights granted to You by this License
+ as of the date You commence an action, including a cross-claim or counterclaim,
+ against Licensor or any licensee alleging that the Original Work infringes a
+ patent. This termination provision shall not apply for an action alleging
+ patent infringement by combinations of the Original Work with other software or
+ hardware.
+ .
+ 11) Jurisdiction, Venue and Governing Law. Any action or suit relating to this
+ License may be brought only in the courts of a jurisdiction wherein the
+ Licensor resides or in which Licensor conducts its primary business, and under
+ the laws of that jurisdiction excluding its conflict-of-law provisions. The
+ application of the United Nations Convention on Contracts for the International
+ Sale of Goods is expressly excluded. Any use of the Original Work outside the
+ scope of this License or after its termination shall be subject to the
+ requirements and penalties of the U.S. Copyright Act, 17 U.S.C. § 101 et
+ seq., the equivalent laws of other countries, and international treaty. This
+ section shall survive the termination of this License.
+ .
+ 12) Attorneys Fees. In any action to enforce the terms of this License or
+ seeking damages relating thereto, the prevailing party shall be entitled to
+ recover its costs and expenses, including, without limitation, reasonable
+ attorneys' fees and costs incurred in connection with such action, including
+  any appeal of such action. This section shall survive the termination of this
+ License.
+ .
+ 13) Miscellaneous. This License represents the complete agreement concerning
+ the subject matter hereof. If any provision of this License is held to be
+ unenforceable, such provision shall be reformed only to the extent necessary to
+ make it enforceable.
+ .
+ 14) Definition of "You" in This License. "You" throughout this License, whether
+ in upper or lower case, means an individual or a legal entity exercising rights
+ under, and complying with all of the terms of, this License. For legal
+ entities, "You" includes any entity that controls, is controlled by, or is
+ under common control with you. For purposes of this definition, "control" means
+ (i) the power, direct or indirect, to cause the direction or management of such
+ entity, whether by contract or otherwise, or (ii) ownership of fifty percent
+ (50%) or more of the outstanding shares, or (iii) beneficial ownership of such
+ entity.
+ .
+ 15) Right to Use. You may use the Original Work in all ways not otherwise
+ restricted or conditioned by this License or by law, and Licensor promises not
+ to interfere with or be responsible for such uses by You.
+ .
+ This license is Copyright (C) 2003-2004 Lawrence E. Rosen. All rights reserved.
+ Permission is hereby granted to copy and distribute this license without
+ modification. This license may not be modified without the express written
+ permission of its copyright owner.
+
+License: Apache-2.0
+ On Debian machines the full text of the Apache License 2.0 can be found in the
+ file /usr/share/common-licenses/Apache-2.0.

debian/freeipa-client-epn.install

@@ -0,0 +1,7 @@
+etc/ipa/epn.conf
+etc/ipa/epn/expire_msg.template
+${env:systemdsystemunitdir}/ipa-epn.service
+${env:systemdsystemunitdir}/ipa-epn.timer
+usr/sbin/ipa-epn
+usr/share/man/man1/ipa-epn.1
+usr/share/man/man5/epn.conf.5

debian/freeipa-client-samba.install

@@ -0,0 +1,2 @@
+usr/sbin/ipa-client-samba
+usr/share/man/man1/ipa-client-samba.1*

debian/freeipa-client.dirs

@@ -0,0 +1,6 @@
+etc/ipa
+etc/ipa/nssdb
+etc/krb5.conf.d
+etc/pki/nssdb
+var/lib/ipa-client/pki
+var/lib/ipa-client/sysrestore

debian/freeipa-client.install

@@ -0,0 +1,19 @@
+etc/default/certmonger
+usr/bin/ipa
+usr/lib/ipa/acme/certbot-dns-ipa
+usr/sbin/ipa-certupdate
+usr/sbin/ipa-client-automount
+usr/sbin/ipa-client-install
+usr/sbin/ipa-getkeytab
+usr/sbin/ipa-join
+usr/sbin/ipa-rmkeytab
+usr/share/bash-completion/completions/ipa
+usr/share/ipa/client/*.template
+usr/share/man/man1/ipa.1*
+usr/share/man/man1/ipa-certupdate.1*
+usr/share/man/man1/ipa-client-automount.1*
+usr/share/man/man1/ipa-client-install.1*
+usr/share/man/man1/ipa-getkeytab.1*
+usr/share/man/man1/ipa-join.1*
+usr/share/man/man1/ipa-rmkeytab.1*
+usr/share/man/man5/default.conf.5*

debian/freeipa-client.lintian-overrides

@@ -0,0 +1 @@
+possible-bashism-in-maintainer-script

debian/freeipa-client.postrm

@@ -0,0 +1,22 @@
+#!/bin/sh
+set -e
+
+if [ "$1" = purge ]; then
+    rm -f /etc/ipa/default.conf
+    rm -f /etc/pki/nssdb/cert8.db \
+          /etc/pki/nssdb/key3.db \
+          /etc/pki/nssdb/secmod.db
+    rm -f /etc/ipa/nssdb/cert8.db \
+          /etc/ipa/nssdb/key3.db \
+          /etc/ipa/nssdb/pwdfile.txt \
+          /etc/ipa/nssdb/secmod.db \
+          /etc/ipa/nssdb/*.orig
+    rmdir /etc/pki/nssdb || true
+    rmdir /etc/ipa/nssdb || true
+    rmdir /etc/ipa || true
+    rm -rf /var/lib/ipa-client
+    rm -f /var/log/ipaclient-upgrade.log
+fi
+
+#DEBHELPER#
+

debian/freeipa-client.tmpfiles

@@ -0,0 +1 @@
+d /run/ipa 0711 root root

debian/freeipa-common.install

@@ -0,0 +1 @@
+usr/share/locale

debian/freeipa-server-dns.install

@@ -0,0 +1,3 @@
+usr/sbin/ipa-dns-install
+usr/share/man/man1/ipa-dns-install.1*
+

debian/freeipa-server-trust-ad.install

@@ -0,0 +1,7 @@
+etc/dbus-1/system.d/oddjob-ipa-trust.conf
+etc/oddjobd.conf.d/oddjobd-ipa-trust.conf
+usr/lib/*/samba/pdb/ipasam.so
+usr/lib/ipa/oddjob/com.redhat.idm.trust-fetch-domains
+usr/sbin/ipa-adtrust-install
+usr/share/ipa/smb.conf.empty
+usr/share/man/man1/ipa-adtrust-install.1*

debian/freeipa-server-trust-ad.lintian-overrides

@@ -0,0 +1,2 @@
+# plugin
+custom-library-search-path

debian/freeipa-server.dirs

@@ -0,0 +1,6 @@
+etc/ipa/custodia
+etc/ipa/dnssec
+var/lib/ipa/backup
+var/lib/ipa/certs
+var/lib/ipa/passwds
+var/lib/ipa/private

debian/freeipa-server.docs

@@ -0,0 +1 @@
+README.md

debian/freeipa-server.install

@@ -0,0 +1,127 @@
+etc/default/ipa-dnskeysyncd
+etc/default/ipa-ods-exporter
+etc/ipa/html/*
+etc/ipa/kdcproxy
+etc/dbus-1/system.d/org.freeipa.server.conf
+etc/oddjobd.conf.d/ipa-server.conf
+${env:systemdsystemunitdir}/ipa-ccache-sweep.service
+${env:systemdsystemunitdir}/ipa-ccache-sweep.timer
+${env:systemdsystemunitdir}/ipa-custodia.service
+${env:systemdsystemunitdir}/ipa-dnskeysyncd.service
+${env:systemdsystemunitdir}/ipa-ods-exporter.service
+${env:systemdsystemunitdir}/ipa-ods-exporter.socket
+${env:systemdsystemunitdir}/ipa-otpd.socket
+${env:systemdsystemunitdir}/ipa-otpd@.service
+${env:systemdsystemunitdir}/ipa.service
+usr/lib/*/dirsrv/plugins/libipa_cldap.so
+usr/lib/*/dirsrv/plugins/libipa_dns.so
+usr/lib/*/dirsrv/plugins/libipa_enrollment_extop.so
+usr/lib/*/dirsrv/plugins/libipa_extdom_extop.so
+usr/lib/*/dirsrv/plugins/libipa_graceperiod.so
+usr/lib/*/dirsrv/plugins/libipa_lockout.so
+usr/lib/*/dirsrv/plugins/libipa_modrdn.so
+usr/lib/*/dirsrv/plugins/libipa_otp_counter.so
+usr/lib/*/dirsrv/plugins/libipa_otp_lasttoken.so
+usr/lib/*/dirsrv/plugins/libipa_pwd_extop.so
+usr/lib/*/dirsrv/plugins/libipa_range_check.so
+usr/lib/*/dirsrv/plugins/libipa_repl_version.so
+usr/lib/*/dirsrv/plugins/libipa_sidgen.so
+usr/lib/*/dirsrv/plugins/libipa_sidgen_task.so
+usr/lib/*/dirsrv/plugins/libipa_uuid.so
+usr/lib/*/dirsrv/plugins/libipa_winsync.so
+usr/lib/*/dirsrv/plugins/libtopology.so
+usr/lib/*/krb5/plugins/kdb/*.so
+usr/lib/certmonger/dogtag-ipa-ca-renew-agent-submit
+usr/lib/certmonger/ipa-server-guard
+usr/lib/ipa/certmonger/*
+usr/lib/ipa/custodia/ipa-custodia-dmldap
+usr/lib/ipa/custodia/ipa-custodia-pki-tomcat
+usr/lib/ipa/custodia/ipa-custodia-pki-tomcat-wrapped
+usr/lib/ipa/custodia/ipa-custodia-ra-agent
+usr/lib/ipa/ipa-ccache-sweeper
+usr/lib/ipa/ipa-custodia
+usr/lib/ipa/ipa-custodia-check
+usr/lib/ipa/ipa-dnskeysync-replica
+usr/lib/ipa/ipa-dnskeysyncd
+usr/lib/ipa/ipa-httpd-kdcproxy
+usr/lib/ipa/ipa-httpd-pwdreader
+usr/lib/ipa/ipa-ods-exporter
+usr/lib/ipa/ipa-otpd
+usr/lib/ipa/ipa-pki-retrieve-key
+usr/lib/ipa/ipa-pki-wait-running
+usr/lib/ipa/ipa-print-pac
+usr/lib/ipa/ipa-subids
+usr/lib/ipa/oddjob/org.freeipa.server.config-enable-sid
+usr/lib/ipa/oddjob/org.freeipa.server.conncheck
+usr/lib/ipa/oddjob/org.freeipa.server.trust-enable-agent
+usr/lib/tmpfiles.d/ipa.conf
+usr/sbin/ipa-acme-manage
+usr/sbin/ipa-advise
+usr/sbin/ipa-backup
+usr/sbin/ipa-ca-install
+usr/sbin/ipa-cacert-manage
+usr/sbin/ipa-cert-fix
+usr/sbin/ipa-compat-manage
+usr/sbin/ipa-crlgen-manage
+usr/sbin/ipa-csreplica-manage
+usr/sbin/ipa-kra-install
+usr/sbin/ipa-ldap-updater
+usr/sbin/ipa-managed-entries
+usr/sbin/ipa-nis-manage
+usr/sbin/ipa-otptoken-import
+usr/sbin/ipa-pkinit-manage
+usr/sbin/ipa-replica-conncheck
+usr/sbin/ipa-replica-install
+usr/sbin/ipa-replica-manage
+usr/sbin/ipa-restore
+usr/sbin/ipa-server-certinstall
+usr/sbin/ipa-server-install
+usr/sbin/ipa-server-upgrade
+usr/sbin/ipa-winsync-migrate
+usr/sbin/ipactl
+usr/share/ipa/*.ldif
+usr/share/ipa/*.template
+usr/share/ipa/*.uldif
+usr/share/ipa/advise/legacy/*.template
+usr/share/ipa/bind.ipa-ext.conf.template
+usr/share/ipa/gssapi.login
+usr/share/ipa/html/*
+usr/share/ipa/ipaca_*.ini
+usr/share/ipa/ipakrb5.aug
+usr/share/ipa/kdcproxy.wsgi
+usr/share/ipa/migration/*
+usr/share/ipa/profiles/README
+usr/share/ipa/profiles/*.cfg
+usr/share/ipa/schema.d/*
+usr/share/ipa/ui/*
+usr/share/ipa/updates/*
+usr/share/ipa/wsgi.py
+usr/share/ipa/wsgi/*
+usr/share/man/man1/ipa-acme-manage.1*
+usr/share/man/man1/ipa-advise.1*
+usr/share/man/man1/ipa-backup.1*
+usr/share/man/man1/ipa-ca-install.1*
+usr/share/man/man1/ipa-cacert-manage.1*
+usr/share/man/man1/ipa-cert-fix.1*
+usr/share/man/man1/ipa-compat-manage.1*
+usr/share/man/man1/ipa-crlgen-manage.1*
+usr/share/man/man1/ipa-csreplica-manage.1*
+usr/share/man/man1/ipa-kra-install.1*
+usr/share/man/man1/ipa-ldap-updater.1*
+usr/share/man/man1/ipa-managed-entries.1*
+usr/share/man/man1/ipa-nis-manage.1*
+usr/share/man/man1/ipa-otptoken-import.1*
+usr/share/man/man1/ipa-pkinit-manage.1*
+usr/share/man/man1/ipa-replica-conncheck.1*
+usr/share/man/man1/ipa-replica-install.1*
+usr/share/man/man1/ipa-replica-manage.1*
+usr/share/man/man1/ipa-restore.1*
+usr/share/man/man1/ipa-server-certinstall.1*
+usr/share/man/man1/ipa-server-install.1*
+usr/share/man/man1/ipa-server-upgrade.1*
+usr/share/man/man1/ipa-winsync-migrate.1*
+usr/share/man/man8/ipactl.8*
+var/lib/ipa/pki-ca
+var/lib/ipa/gssproxy
+var/lib/ipa/sysrestore
+var/lib/ipa/sysupgrade

debian/freeipa-server.links

@@ -0,0 +1,8 @@
+/etc/ipa/html/browserconfig.html	usr/share/ipa/html/browserconfig.html
+/etc/ipa/html/ffconfig.js		usr/share/ipa/html/ffconfig.js
+/etc/ipa/html/ffconfig_page.js		usr/share/ipa/html/ffconfig_page.js
+/etc/ipa/html/ssbrowser.html		usr/share/ipa/html/ssbrowser.html
+/etc/ipa/html/unauthorized.html		usr/share/ipa/html/unauthorized.html
+/usr/share/javascript/prototype/prototype.js       	/usr/share/ipa/ipagui/static/javascript/prototype.js
+/usr/share/javascript/scriptaculous/effects.js		/usr/share/ipa/ipagui/static/javascript/effects.js
+/usr/share/javascript/scriptaculous/scriptaculous.js	/usr/share/ipa/ipagui/static/javascript/scriptaculous.js

debian/freeipa-server.lintian-overrides

@@ -0,0 +1,7 @@
+# we really need apache2
+web-application-should-not-depend-unconditionally-on-apache2
+# embedded versions used for better performance and function
+embedded-javascript-library
+# this is how we need them
+non-standard-dir-perm var/cache/bind/data/ *
+non-standard-dir-perm var/lib/ipa/backup/ *

debian/freeipa-server.postinst

@@ -0,0 +1,78 @@
+#!/bin/sh
+set -e
+
+OUT=/dev/null
+
+if [ "$1" = configure ]; then
+    if ! getent passwd kdcproxy  > $OUT; then
+        adduser --quiet --system --home / \
+            --shell /usr/sbin/nologin --group \
+            --no-create-home --gecos "IPA KDC Proxy User" \
+            kdcproxy > $OUT
+    fi
+    if ! getent passwd ipaapi  > $OUT; then
+        adduser --quiet --system --home / \
+            --shell /usr/sbin/nologin --group \
+            --no-create-home --gecos "IPA Framework User" \
+            ipaapi > $OUT
+    fi
+
+    chmod 711 /var/lib/ipa/sysrestore > $OUT || true
+    chmod 700 /var/lib/ipa/passwds > $OUT || true
+    chmod 700 /var/lib/ipa/private > $OUT || true
+
+    # add www-data to ipaapi group
+    if ! id -Gn www-data | grep '\bipaapi\b' >/dev/null; then
+        usermod www-data -a -G ipaapi
+    fi
+
+    if [ -e /usr/share/apache2/apache2-maintscript-helper ]; then
+        . /usr/share/apache2/apache2-maintscript-helper
+	if [ ! -e /etc/apache2/mods-enabled/auth_gssapi.load ]; then
+            apache2_invoke enmod auth_gssapi || exit $?
+        fi
+	if [ ! -e /etc/apache2/mods-enabled/authz_user.load ]; then
+            apache2_invoke enmod authz_user || exit $?
+        fi
+	if [ ! -e /etc/apache2/mods-enabled/deflate.load ]; then
+            apache2_invoke enmod deflate || exit $?
+        fi
+	if [ ! -e /etc/apache2/mods-enabled/expires.load ]; then
+            apache2_invoke enmod expires || exit $?
+        fi
+	if [ ! -e /etc/apache2/mods-enabled/headers.load ]; then
+            apache2_invoke enmod headers || exit $?
+        fi
+	if [ ! -e /etc/apache2/mods-enabled/lookup_identity.load ]; then
+            apache2_invoke enmod lookup_identity || exit $?
+        fi
+	if [ ! -e /etc/apache2/mods-enabled/proxy.load ]; then
+            apache2_invoke enmod proxy || exit $?
+        fi
+	if [ ! -e /etc/apache2/mods-enabled/proxy_ajp.load ]; then
+            apache2_invoke enmod proxy_ajp || exit $?
+        fi
+	if [ ! -e /etc/apache2/mods-enabled/proxy_http.load ]; then
+            apache2_invoke enmod proxy_http || exit $?
+        fi
+	if [ ! -e /etc/apache2/mods-enabled/rewrite.load ]; then
+            apache2_invoke enmod rewrite || exit $?
+        fi
+	if [ ! -e /etc/apache2/mods-enabled/session.load ]; then
+            apache2_invoke enmod session || exit $?
+        fi
+	if [ ! -e /etc/apache2/mods-enabled/session_cookie.load ]; then
+            apache2_invoke enmod session_cookie || exit $?
+        fi
+	if [ ! -e /etc/apache2/mods-enabled/ssl.load ]; then
+            apache2_invoke enmod ssl || exit $?
+        fi
+
+	# Enable default SSL site
+	if [ ! -e /etc/apache2/sites-enabled/default-ssl.conf ]; then
+            apache2_invoke ensite default-ssl || exit $?
+        fi
+    fi
+fi
+
+#DEBHELPER#

debian/freeipa-server.postrm

@@ -0,0 +1,65 @@
+#!/bin/sh
+set -e
+
+case "$1" in
+    remove|purge)
+        if [ -e /usr/share/apache2/apache2-maintscript-helper ]; then
+            . /usr/share/apache2/apache2-maintscript-helper
+
+            if [ -e /etc/apache2/mods-enabled/auth_kerb.load ]; then
+                apache2_invoke dismod auth_kerb || exit $?
+            fi
+            if [ -e /etc/apache2/mods-enabled/auth_gssapi.load ]; then
+                apache2_invoke dismod auth_gssapi || exit $?
+            fi
+            if [ -e /etc/apache2/mods-enabled/authz_user.load ]; then
+                apache2_invoke dismod authz_user || exit $?
+            fi
+            if [ -e /etc/apache2/mods-enabled/deflate.load ]; then
+                apache2_invoke dismod deflate || exit $?
+            fi
+            if [ -e /etc/apache2/mods-enabled/expires.load ]; then
+                apache2_invoke dismod expires || exit $?
+            fi
+            if [ -e /etc/apache2/mods-enabled/headers.load ]; then
+                apache2_invoke dismod headers || exit $?
+            fi
+            if [ -e /etc/apache2/mods-enabled/lookup_identity.load ]; then
+                apache2_invoke dismod lookup_identity || exit $?
+            fi
+            if [ -e /etc/apache2/mods-enabled/proxy.load ]; then
+                apache2_invoke dismod proxy || exit $?
+            fi
+            if [ -e /etc/apache2/mods-enabled/proxy_ajp.load ]; then
+                apache2_invoke dismod proxy_ajp || exit $?
+            fi
+            if [ -e /etc/apache2/mods-enabled/proxy_http.load ]; then
+                apache2_invoke dismod proxy_http || exit $?
+            fi
+            if [ -e /etc/apache2/mods-enabled/rewrite.load ]; then
+                apache2_invoke dismod rewrite || exit $?
+            fi
+            if [ -e /etc/apache2/mods-enabled/session.load ]; then
+                apache2_invoke dismod session || exit $?
+            fi
+            if [ -e /etc/apache2/mods-enabled/session_cookie.load ]; then
+                apache2_invoke dismod session_cookie || exit $?
+            fi
+            if [ -e /etc/apache2/mods-enabled/ssl.load ]; then
+                apache2_invoke dismod ssl || exit $?
+            fi
+        fi
+    ;;
+esac
+case "$1" in
+    purge)
+        rm -f \
+            /var/log/ipareplica-conncheck.log \
+            /var/log/ipareplica-install.log \
+            /var/log/ipaserver-install.log \
+            /var/log/ipaserver-uninstall.log \
+            /var/log/ipaupgrade.log
+    ;;
+esac
+
+#DEBHELPER#

debian/freeipa-server.prerm

@@ -0,0 +1,26 @@
+#!/bin/sh
+set -e
+
+if [ -e /usr/share/apache2/apache2-maintscript-helper ]; then
+    . /usr/share/apache2/apache2-maintscript-helper
+    if [ -e /etc/apache2/mods-enabled/auth_kerb ]; then
+        apache2_invoke dismod auth_kerb || exit $?
+    fi
+    if [ -e /etc/apache2/mods-enabled/auth_gssapi ]; then
+        apache2_invoke dismod auth_gssapi || exit $?
+    fi
+    if [ -e /etc/apache2/mods-enabled/expires  ]; then
+        apache2_invoke dismod expires || exit $?
+    fi
+    if [ -e /etc/apache2/mods-enabled/headers  ]; then
+        apache2_invoke dismod headers || exit $?
+    fi
+    if [ -e /etc/apache2/mods-enabled/proxy  ]; then
+        apache2_invoke dismod proxy || exit $?
+    fi
+    if [ -e /etc/apache2/mods-enabled/rewrite  ]; then
+        apache2_invoke dismod rewrite || exit $?
+    fi
+fi
+
+#DEBHELPER#

debian/freeipa-tests.install

@@ -0,0 +1,6 @@
+usr/bin/ipa-run-tests
+usr/bin/ipa-test-config
+usr/bin/ipa-test-task
+usr/share/man/man1/ipa-run-tests.1*
+usr/share/man/man1/ipa-test-config.1*
+usr/share/man/man1/ipa-test-task.1*

debian/gitlab-ci.yml

@@ -0,0 +1,6 @@
+include:
+  - https://salsa.debian.org/salsa-ci-team/pipeline/raw/master/salsa-ci.yml
+  - https://salsa.debian.org/salsa-ci-team/pipeline/raw/master/pipeline-jobs.yml
+
+piuparts:
+  allow_failure: true

debian/missing-sources/dojo/Deferred.js

@@ -0,0 +1,320 @@
+define([
+	"./has",
+	"./_base/lang",
+	"./errors/CancelError",
+	"./promise/Promise",
+	"./has!config-deferredInstrumentation?./promise/instrumentation"
+], function(has, lang, CancelError, Promise, instrumentation){
+	"use strict";
+
+	// module:
+	//		dojo/Deferred
+
+	var PROGRESS = 0,
+			RESOLVED = 1,
+			REJECTED = 2;
+	var FULFILLED_ERROR_MESSAGE = "This deferred has already been fulfilled.";
+
+	var freezeObject = Object.freeze || function(){};
+
+	var signalWaiting = function(waiting, type, result, rejection, deferred){
+		if(has("config-deferredInstrumentation")){
+			if(type === REJECTED && Deferred.instrumentRejected && waiting.length === 0){
+				Deferred.instrumentRejected(result, false, rejection, deferred);
+			}
+		}
+
+		for(var i = 0; i < waiting.length; i++){
+			signalListener(waiting[i], type, result, rejection);
+		}
+	};
+
+	var signalListener = function(listener, type, result, rejection){
+		var func = listener[type];
+		var deferred = listener.deferred;
+		if(func){
+			try{
+				var newResult = func(result);
+				if(type === PROGRESS){
+					if(typeof newResult !== "undefined"){
+						signalDeferred(deferred, type, newResult);
+					}
+				}else{
+					if(newResult && typeof newResult.then === "function"){
+						listener.cancel = newResult.cancel;
+						newResult.then(
+								// Only make resolvers if they're actually going to be used
+								makeDeferredSignaler(deferred, RESOLVED),
+								makeDeferredSignaler(deferred, REJECTED),
+								makeDeferredSignaler(deferred, PROGRESS));
+						return;
+					}
+					signalDeferred(deferred, RESOLVED, newResult);
+				}
+			}catch(error){
+				signalDeferred(deferred, REJECTED, error);
+			}
+		}else{
+			signalDeferred(deferred, type, result);
+		}
+
+		if(has("config-deferredInstrumentation")){
+			if(type === REJECTED && Deferred.instrumentRejected){
+				Deferred.instrumentRejected(result, !!func, rejection, deferred.promise);
+			}
+		}
+	};
+
+	var makeDeferredSignaler = function(deferred, type){
+		return function(value){
+			signalDeferred(deferred, type, value);
+		};
+	};
+
+	var signalDeferred = function(deferred, type, result){
+		if(!deferred.isCanceled()){
+			switch(type){
+				case PROGRESS:
+					deferred.progress(result);
+					break;
+				case RESOLVED:
+					deferred.resolve(result);
+					break;
+				case REJECTED:
+					deferred.reject(result);
+					break;
+			}
+		}
+	};
+
+	var Deferred = function(canceler){
+		// summary:
+		//		Creates a new deferred. This API is preferred over
+		//		`dojo/_base/Deferred`.
+		// description:
+		//		Creates a new deferred, as an abstraction over (primarily)
+		//		asynchronous operations. The deferred is the private interface
+		//		that should not be returned to calling code. That's what the
+		//		`promise` is for. See `dojo/promise/Promise`.
+		// canceler: Function?
+		//		Will be invoked if the deferred is canceled. The canceler
+		//		receives the reason the deferred was canceled as its argument.
+		//		The deferred is rejected with its return value, or a new
+		//		`dojo/errors/CancelError` instance.
+
+		// promise: dojo/promise/Promise
+		//		The public promise object that clients can add callbacks to. 
+		var promise = this.promise = new Promise();
+
+		var deferred = this;
+		var fulfilled, result, rejection;
+		var canceled = false;
+		var waiting = [];
+
+		if(has("config-deferredInstrumentation") && Error.captureStackTrace){
+			Error.captureStackTrace(deferred, Deferred);
+			Error.captureStackTrace(promise, Deferred);
+		}
+
+		this.isResolved = promise.isResolved = function(){
+			// summary:
+			//		Checks whether the deferred has been resolved.
+			// returns: Boolean
+
+			return fulfilled === RESOLVED;
+		};
+
+		this.isRejected = promise.isRejected = function(){
+			// summary:
+			//		Checks whether the deferred has been rejected.
+			// returns: Boolean
+
+			return fulfilled === REJECTED;
+		};
+
+		this.isFulfilled = promise.isFulfilled = function(){
+			// summary:
+			//		Checks whether the deferred has been resolved or rejected.
+			// returns: Boolean
+
+			return !!fulfilled;
+		};
+
+		this.isCanceled = promise.isCanceled = function(){
+			// summary:
+			//		Checks whether the deferred has been canceled.
+			// returns: Boolean
+
+			return canceled;
+		};
+
+		this.progress = function(update, strict){
+			// summary:
+			//		Emit a progress update on the deferred.
+			// description:
+			//		Emit a progress update on the deferred. Progress updates
+			//		can be used to communicate updates about the asynchronous
+			//		operation before it has finished.
+			// update: any
+			//		The progress update. Passed to progbacks.
+			// strict: Boolean?
+			//		If strict, will throw an error if the deferred has already
+			//		been fulfilled and consequently no progress can be emitted.
+			// returns: dojo/promise/Promise
+			//		Returns the original promise for the deferred.
+
+			if(!fulfilled){
+				signalWaiting(waiting, PROGRESS, update, null, deferred);
+				return promise;
+			}else if(strict === true){
+				throw new Error(FULFILLED_ERROR_MESSAGE);
+			}else{
+				return promise;
+			}
+		};
+
+		this.resolve = function(value, strict){
+			// summary:
+			//		Resolve the deferred.
+			// description:
+			//		Resolve the deferred, putting it in a success state.
+			// value: any
+			//		The result of the deferred. Passed to callbacks.
+			// strict: Boolean?
+			//		If strict, will throw an error if the deferred has already
+			//		been fulfilled and consequently cannot be resolved.
+			// returns: dojo/promise/Promise
+			//		Returns the original promise for the deferred.
+
+			if(!fulfilled){
+				// Set fulfilled, store value. After signaling waiting listeners unset
+				// waiting.
+				signalWaiting(waiting, fulfilled = RESOLVED, result = value, null, deferred);
+				waiting = null;
+				return promise;
+			}else if(strict === true){
+				throw new Error(FULFILLED_ERROR_MESSAGE);
+			}else{
+				return promise;
+			}
+		};
+
+		var reject = this.reject = function(error, strict){
+			// summary:
+			//		Reject the deferred.
+			// description:
+			//		Reject the deferred, putting it in an error state.
+			// error: any
+			//		The error result of the deferred. Passed to errbacks.
+			// strict: Boolean?
+			//		If strict, will throw an error if the deferred has already
+			//		been fulfilled and consequently cannot be rejected.
+			// returns: dojo/promise/Promise
+			//		Returns the original promise for the deferred.
+
+			if(!fulfilled){
+				if(has("config-deferredInstrumentation") && Error.captureStackTrace){
+					Error.captureStackTrace(rejection = {}, reject);
+				}
+				signalWaiting(waiting, fulfilled = REJECTED, result = error, rejection, deferred);
+				waiting = null;
+				return promise;
+			}else if(strict === true){
+				throw new Error(FULFILLED_ERROR_MESSAGE);
+			}else{
+				return promise;
+			}
+		};
+
+		this.then = promise.then = function(callback, errback, progback){
+			// summary:
+			//		Add new callbacks to the deferred.
+			// description:
+			//		Add new callbacks to the deferred. Callbacks can be added
+			//		before or after the deferred is fulfilled.
+			// callback: Function?
+			//		Callback to be invoked when the promise is resolved.
+			//		Receives the resolution value.
+			// errback: Function?
+			//		Callback to be invoked when the promise is rejected.
+			//		Receives the rejection error.
+			// progback: Function?
+			//		Callback to be invoked when the promise emits a progress
+			//		update. Receives the progress update.
+			// returns: dojo/promise/Promise
+			//		Returns a new promise for the result of the callback(s).
+			//		This can be used for chaining many asynchronous operations.
+
+			var listener = [progback, callback, errback];
+			// Ensure we cancel the promise we're waiting for, or if callback/errback
+			// have returned a promise, cancel that one.
+			listener.cancel = promise.cancel;
+			listener.deferred = new Deferred(function(reason){
+				// Check whether cancel is really available, returned promises are not
+				// required to expose `cancel`
+				return listener.cancel && listener.cancel(reason);
+			});
+			if(fulfilled && !waiting){
+				signalListener(listener, fulfilled, result, rejection);
+			}else{
+				waiting.push(listener);
+			}
+			return listener.deferred.promise;
+		};
+
+		this.cancel = promise.cancel = function(reason, strict){
+			// summary:
+			//		Inform the deferred it may cancel its asynchronous operation.
+			// description:
+			//		Inform the deferred it may cancel its asynchronous operation.
+			//		The deferred's (optional) canceler is invoked and the
+			//		deferred will be left in a rejected state. Can affect other
+			//		promises that originate with the same deferred.
+			// reason: any
+			//		A message that may be sent to the deferred's canceler,
+			//		explaining why it's being canceled.
+			// strict: Boolean?
+			//		If strict, will throw an error if the deferred has already
+			//		been fulfilled and consequently cannot be canceled.
+			// returns: any
+			//		Returns the rejection reason if the deferred was canceled
+			//		normally.
+
+			if(!fulfilled){
+				// Cancel can be called even after the deferred is fulfilled
+				if(canceler){
+					var returnedReason = canceler(reason);
+					reason = typeof returnedReason === "undefined" ? reason : returnedReason;
+				}
+				canceled = true;
+				if(!fulfilled){
+					// Allow canceler to provide its own reason, but fall back to a CancelError
+					if(typeof reason === "undefined"){
+						reason = new CancelError();
+					}
+					reject(reason);
+					return reason;
+				}else if(fulfilled === REJECTED && result === reason){
+					return reason;
+				}
+			}else if(strict === true){
+				throw new Error(FULFILLED_ERROR_MESSAGE);
+			}
+		};
+
+		freezeObject(promise);
+	};
+
+	Deferred.prototype.toString = function(){
+		// returns: String
+		//		Returns `[object Deferred]`.
+
+		return "[object Deferred]";
+	};
+
+	if(instrumentation){
+		instrumentation(Deferred);
+	}
+
+	return Deferred;
+});

debian/missing-sources/dojo/Evented.js

@@ -0,0 +1,35 @@
+define(["./aspect", "./on"], function(aspect, on){
+	// module:
+	//		dojo/Evented
+
+ 	"use strict";
+ 	var after = aspect.after;
+	function Evented(){
+		// summary:
+		//		A class that can be used as a mixin or base class,
+		//		to add on() and emit() methods to a class
+		//		for listening for events and emitting events:
+		//
+		//		|	define(["dojo/Evented"], function(Evented){
+		//		|		var EventedWidget = dojo.declare([Evented, dijit._Widget], {...});
+		//		|		widget = new EventedWidget();
+		//		|		widget.on("open", function(event){
+		//		|		... do something with event
+		//		|	 });
+		//		|
+		//		|	widget.emit("open", {name:"some event", ...});
+	}
+	Evented.prototype = {
+		on: function(type, listener){
+			return on.parse(this, type, listener, function(target, type){
+				return after(target, 'on' + type, listener, true);
+			});
+		},
+		emit: function(type, event){
+			var args = [this];
+			args.push.apply(args, arguments);
+			return on.emit.apply(on, args);
+		}
+	};
+	return Evented;
+});

debian/missing-sources/dojo/NodeList-dom.js

@@ -0,0 +1,514 @@
+define(["./_base/kernel", "./query", "./_base/array", "./_base/lang", "./dom-class", "./dom-construct", "./dom-geometry", "./dom-attr", "./dom-style"], function(dojo, query, array, lang, domCls, domCtr, domGeom, domAttr, domStyle){
+
+	// module:
+	//		dojo/NodeList-dom.js
+
+	/*=====
+	 return function(){
+		 // summary:
+		 //		Adds DOM related methods to NodeList, and returns NodeList constructor.
+	 };
+	 =====*/
+
+	var magicGuard = function(a){
+		// summary:
+		//		the guard function for dojo.attr() and dojo.style()
+		return a.length == 1 && (typeof a[0] == "string"); // inline'd type check
+	};
+
+	var orphan = function(node){
+		// summary:
+		//		function to orphan nodes
+		var p = node.parentNode;
+		if(p){
+			p.removeChild(node);
+		}
+	};
+	// FIXME: should we move orphan() to dojo.html?
+
+	var NodeList = query.NodeList,
+		awc = NodeList._adaptWithCondition,
+		aafe = NodeList._adaptAsForEach,
+		aam = NodeList._adaptAsMap;
+
+	function getSet(module){
+		return function(node, name, value){
+			if(arguments.length == 2){
+				return module[typeof name == "string" ? "get" : "set"](node, name);
+			}
+			// setter
+			return module.set(node, name, value);
+		};
+	}
+
+	lang.extend(NodeList, {
+		_normalize: function(/*String||Element||Object||NodeList*/content, /*DOMNode?*/refNode){
+			// summary:
+			//		normalizes data to an array of items to insert.
+			// description:
+			//		If content is an object, it can have special properties "template" and
+			//		"parse". If "template" is defined, then the template value is run through
+			//		dojo.string.substitute (if dojo/string.substitute() has been dojo.required elsewhere),
+			//		or if templateFunc is a function on the content, that function will be used to
+			//		transform the template into a final string to be used for for passing to dojo/dom-construct.toDom().
+			//		If content.parse is true, then it is remembered for later, for when the content
+			//		nodes are inserted into the DOM. At that point, the nodes will be parsed for widgets
+			//		(if dojo.parser has been dojo.required elsewhere).
+
+			//Wanted to just use a DocumentFragment, but for the array/NodeList
+			//case that meant using cloneNode, but we may not want that.
+			//Cloning should only happen if the node operations span
+			//multiple refNodes. Also, need a real array, not a NodeList from the
+			//DOM since the node movements could change those NodeLists.
+
+			var parse = content.parse === true;
+
+			//Do we have an object that needs to be run through a template?
+			if(typeof content.template == "string"){
+				var templateFunc = content.templateFunc || (dojo.string && dojo.string.substitute);
+				content = templateFunc ? templateFunc(content.template, content) : content;
+			}
+
+			var type = (typeof content);
+			if(type == "string" || type == "number"){
+				content = domCtr.toDom(content, (refNode && refNode.ownerDocument));
+				if(content.nodeType == 11){
+					//DocumentFragment. It cannot handle cloneNode calls, so pull out the children.
+					content = lang._toArray(content.childNodes);
+				}else{
+					content = [content];
+				}
+			}else if(!lang.isArrayLike(content)){
+				content = [content];
+			}else if(!lang.isArray(content)){
+				//To get to this point, content is array-like, but
+				//not an array, which likely means a DOM NodeList. Convert it now.
+				content = lang._toArray(content);
+			}
+
+			//Pass around the parse info
+			if(parse){
+				content._runParse = true;
+			}
+			return content; //Array
+		},
+
+		_cloneNode: function(/*DOMNode*/ node){
+			// summary:
+			//		private utility to clone a node. Not very interesting in the vanilla
+			//		dojo/NodeList case, but delegates could do interesting things like
+			//		clone event handlers if that is derivable from the node.
+			return node.cloneNode(true);
+		},
+
+		_place: function(/*Array*/ary, /*DOMNode*/refNode, /*String*/position, /*Boolean*/useClone){
+			// summary:
+			//		private utility to handle placing an array of nodes relative to another node.
+			// description:
+			//		Allows for cloning the nodes in the array, and for
+			//		optionally parsing widgets, if ary._runParse is true.
+
+			//Avoid a disallowed operation if trying to do an innerHTML on a non-element node.
+			if(refNode.nodeType != 1 && position == "only"){
+				return;
+			}
+			var rNode = refNode, tempNode;
+
+			//Always cycle backwards in case the array is really a
+			//DOM NodeList and the DOM operations take it out of the live collection.
+			var length = ary.length;
+			for(var i = length - 1; i >= 0; i--){
+				var node = (useClone ? this._cloneNode(ary[i]) : ary[i]);
+
+				//If need widget parsing, use a temp node, instead of waiting after inserting into
+				//real DOM because we need to start widget parsing at one node up from current node,
+				//which could cause some already parsed widgets to be parsed again.
+				if(ary._runParse && dojo.parser && dojo.parser.parse){
+					if(!tempNode){
+						tempNode = rNode.ownerDocument.createElement("div");
+					}
+					tempNode.appendChild(node);
+					dojo.parser.parse(tempNode);
+					node = tempNode.firstChild;
+					while(tempNode.firstChild){
+						tempNode.removeChild(tempNode.firstChild);
+					}
+				}
+
+				if(i == length - 1){
+					domCtr.place(node, rNode, position);
+				}else{
+					rNode.parentNode.insertBefore(node, rNode);
+				}
+				rNode = node;
+			}
+		},
+
+
+		position: aam(domGeom.position),
+		/*=====
+		position: function(){
+			// summary:
+			//		Returns border-box objects (x/y/w/h) of all elements in a node list
+			//		as an Array (*not* a NodeList). Acts like `dojo.position`, though
+			//		assumes the node passed is each node in this list.
+
+			return dojo.map(this, dojo.position); // Array
+		},
+		=====*/
+
+		attr: awc(getSet(domAttr), magicGuard),
+		/*=====
+		attr: function(property, value){
+			// summary:
+			//		gets or sets the DOM attribute for every element in the
+			//		NodeList. See also `dojo.attr`
+			// property: String
+			//		the attribute to get/set
+			// value: String?
+			//		optional. The value to set the property to
+			// returns:
+			//		if no value is passed, the result is an array of attribute values
+			//		If a value is passed, the return is this NodeList
+			// example:
+			//		Make all nodes with a particular class focusable:
+			//	|	dojo.query(".focusable").attr("tabIndex", -1);
+			// example:
+			//		Disable a group of buttons:
+			//	|	dojo.query("button.group").attr("disabled", true);
+			// example:
+			//		innerHTML can be assigned or retrieved as well:
+			//	|	// get the innerHTML (as an array) for each list item
+			//	|	var ih = dojo.query("li.replaceable").attr("innerHTML");
+			return; // dojo/NodeList|Array
+		},
+		=====*/
+
+		style: awc(getSet(domStyle), magicGuard),
+		/*=====
+		style: function(property, value){
+			// summary:
+			//		gets or sets the CSS property for every element in the NodeList
+			// property: String
+			//		the CSS property to get/set, in JavaScript notation
+			//		("lineHieght" instead of "line-height")
+			// value: String?
+			//		optional. The value to set the property to
+			// returns:
+			//		if no value is passed, the result is an array of strings.
+			//		If a value is passed, the return is this NodeList
+			return; // dojo/NodeList
+			return; // Array
+		},
+		=====*/
+
+		addClass: aafe(domCls.add),
+		/*=====
+		addClass: function(className){
+			// summary:
+			//		adds the specified class to every node in the list
+			// className: String|Array
+			//		A String class name to add, or several space-separated class names,
+			//		or an array of class names.
+			return; // dojo/NodeList
+		},
+		=====*/
+
+		removeClass: aafe(domCls.remove),
+		/*=====
+		removeClass: function(className){
+			// summary:
+			//		removes the specified class from every node in the list
+			// className: String|Array?
+			//		An optional String class name to remove, or several space-separated
+			//		class names, or an array of class names. If omitted, all class names
+			//		will be deleted.
+			// returns:
+			//		this list
+			return; // dojo/NodeList
+		},
+		=====*/
+
+		toggleClass: aafe(domCls.toggle),
+		/*=====
+		toggleClass: function(className, condition){
+			// summary:
+			//		Adds a class to node if not present, or removes if present.
+			//		Pass a boolean condition if you want to explicitly add or remove.
+			// condition: Boolean?
+			//		If passed, true means to add the class, false means to remove.
+			// className: String
+			//		the CSS class to add
+			return; // dojo/NodeList
+		},
+		=====*/
+
+		replaceClass: aafe(domCls.replace),
+		/*=====
+		replaceClass: function(addClassStr, removeClassStr){
+			// summary:
+			//		Replaces one or more classes on a node if not present.
+			//		Operates more quickly than calling `removeClass()` and `addClass()`
+			// addClassStr: String|Array
+			//		A String class name to add, or several space-separated class names,
+			//		or an array of class names.
+			// removeClassStr: String|Array?
+			//		A String class name to remove, or several space-separated class names,
+			//		or an array of class names.
+			return; // dojo/NodeList
+		 },
+		 =====*/
+
+		empty: aafe(domCtr.empty),
+		/*=====
+		empty: function(){
+			// summary:
+			//		clears all content from each node in the list. Effectively
+			//		equivalent to removing all child nodes from every item in
+			//		the list.
+			return this.forEach("item.innerHTML='';"); // dojo/NodeList
+			// FIXME: should we be checking for and/or disposing of widgets below these nodes?
+		},
+		=====*/
+
+		removeAttr: aafe(domAttr.remove),
+		/*=====
+		 removeAttr: function(name){
+			// summary:
+			//		Removes an attribute from each node in the list.
+			// name: String
+			//		the name of the attribute to remove
+			return;		// dojo/NodeList
+		},
+		=====*/
+
+		marginBox: aam(domGeom.getMarginBox),
+		/*=====
+		marginBox: function(){
+			// summary:
+			//		Returns margin-box size of nodes
+		 	return; // dojo/NodeList
+		 },
+		 =====*/
+
+		// FIXME: connectPublisher()? connectRunOnce()?
+
+		/*
+		destroy: function(){
+			// summary:
+			//		destroys every item in the list.
+			this.forEach(d.destroy);
+			// FIXME: should we be checking for and/or disposing of widgets below these nodes?
+		},
+		*/
+
+		place: function(/*String||Node*/ queryOrNode, /*String*/ position){
+			// summary:
+			//		places elements of this node list relative to the first element matched
+			//		by queryOrNode. Returns the original NodeList. See: `dojo.place`
+			// queryOrNode:
+			//		may be a string representing any valid CSS3 selector or a DOM node.
+			//		In the selector case, only the first matching element will be used
+			//		for relative positioning.
+			// position:
+			//		can be one of:
+			//
+			//		-	"last" (default)
+			//		-	"first"
+			//		-	"before"
+			//		-	"after"
+			//		-	"only"
+			//		-	"replace"
+			//
+			//		or an offset in the childNodes property
+			var item = query(queryOrNode)[0];
+			return this.forEach(function(node){ domCtr.place(node, item, position); }); // dojo/NodeList
+		},
+
+		orphan: function(/*String?*/ filter){
+			// summary:
+			//		removes elements in this list that match the filter
+			//		from their parents and returns them as a new NodeList.
+			// filter:
+			//		CSS selector like ".foo" or "div > span"
+			// returns:
+			//		NodeList containing the orphaned elements
+			return (filter ? query._filterResult(this, filter) : this).forEach(orphan); // dojo/NodeList
+		},
+
+		adopt: function(/*String||Array||DomNode*/ queryOrListOrNode, /*String?*/ position){
+			// summary:
+			//		places any/all elements in queryOrListOrNode at a
+			//		position relative to the first element in this list.
+			//		Returns a dojo/NodeList of the adopted elements.
+			// queryOrListOrNode:
+			//		a DOM node or a query string or a query result.
+			//		Represents the nodes to be adopted relative to the
+			//		first element of this NodeList.
+			// position:
+			//		can be one of:
+			//
+			//		-	"last" (default)
+			//		-	"first"
+			//		-	"before"
+			//		-	"after"
+			//		-	"only"
+			//		-	"replace"
+			//
+			//		or an offset in the childNodes property
+			return query(queryOrListOrNode).place(this[0], position)._stash(this);	// dojo/NodeList
+		},
+
+		// FIXME: do we need this?
+		query: function(/*String*/ queryStr){
+			// summary:
+			//		Returns a new list whose members match the passed query,
+			//		assuming elements of the current NodeList as the root for
+			//		each search.
+			// example:
+			//		assume a DOM created by this markup:
+			//	|	<div id="foo">
+			//	|		<p>
+			//	|			bacon is tasty, <span>dontcha think?</span>
+			//	|		</p>
+			//	|	</div>
+			//	|	<div id="bar">
+			//	|		<p>great comedians may not be funny <span>in person</span></p>
+			//	|	</div>
+			//		If we are presented with the following definition for a NodeList:
+			//	|	var l = new NodeList(dojo.byId("foo"), dojo.byId("bar"));
+			//		it's possible to find all span elements under paragraphs
+			//		contained by these elements with this sub-query:
+			//	|	var spans = l.query("p span");
+
+			// FIXME: probably slow
+			if(!queryStr){ return this; }
+			var ret = new NodeList;
+			this.map(function(node){
+				// FIXME: why would we ever get undefined here?
+				query(queryStr, node).forEach(function(subNode){
+					if(subNode !== undefined){
+						ret.push(subNode);
+					}
+				});
+			});
+			return ret._stash(this);	// dojo/NodeList
+		},
+
+		filter: function(/*String|Function*/ filter){
+			// summary:
+			//		"masks" the built-in javascript filter() method (supported
+			//		in Dojo via `dojo.filter`) to support passing a simple
+			//		string filter in addition to supporting filtering function
+			//		objects.
+			// filter:
+			//		If a string, a CSS rule like ".thinger" or "div > span".
+			// example:
+			//		"regular" JS filter syntax as exposed in dojo.filter:
+			//		|	dojo.query("*").filter(function(item){
+			//		|		// highlight every paragraph
+			//		|		return (item.nodeName == "p");
+			//		|	}).style("backgroundColor", "yellow");
+			// example:
+			//		the same filtering using a CSS selector
+			//		|	dojo.query("*").filter("p").styles("backgroundColor", "yellow");
+
+			var a = arguments, items = this, start = 0;
+			if(typeof filter == "string"){ // inline'd type check
+				items = query._filterResult(this, a[0]);
+				if(a.length == 1){
+					// if we only got a string query, pass back the filtered results
+					return items._stash(this); // dojo/NodeList
+				}
+				// if we got a callback, run it over the filtered items
+				start = 1;
+			}
+			return this._wrap(array.filter(items, a[start], a[start + 1]), this);	// dojo/NodeList
+		},
+
+		/*
+		// FIXME: should this be "copyTo" and include parenting info?
+		clone: function(){
+			// summary:
+			//		creates node clones of each element of this list
+			//		and returns a new list containing the clones
+		},
+		*/
+
+		addContent: function(/*String||DomNode||Object||dojo/NodeList*/ content, /*String||Integer?*/ position){
+			// summary:
+			//		add a node, NodeList or some HTML as a string to every item in the
+			//		list.  Returns the original list.
+			// description:
+			//		a copy of the HTML content is added to each item in the
+			//		list, with an optional position argument. If no position
+			//		argument is provided, the content is appended to the end of
+			//		each item.
+			// content:
+			//		DOM node, HTML in string format, a NodeList or an Object. If a DOM node or
+			//		NodeList, the content will be cloned if the current NodeList has more than one
+			//		element. Only the DOM nodes are cloned, no event handlers. If it is an Object,
+			//		it should be an object with at "template" String property that has the HTML string
+			//		to insert. If dojo.string has already been dojo.required, then dojo.string.substitute
+			//		will be used on the "template" to generate the final HTML string. Other allowed
+			//		properties on the object are: "parse" if the HTML
+			//		string should be parsed for widgets (dojo.require("dojo.parser") to get that
+			//		option to work), and "templateFunc" if a template function besides dojo.string.substitute
+			//		should be used to transform the "template".
+			// position:
+			//		can be one of:
+			//
+			//		-	"last"||"end" (default)
+			//		-	"first||"start"
+			//		-	"before"
+			//		-	"after"
+			//		-	"replace" (replaces nodes in this NodeList with new content)
+			//		-	"only" (removes other children of the nodes so new content is the only child)
+			//
+			//		or an offset in the childNodes property
+			// example:
+			//		appends content to the end if the position is omitted
+			//	|	dojo.query("h3 > p").addContent("hey there!");
+			// example:
+			//		add something to the front of each element that has a
+			//		"thinger" property:
+			//	|	dojo.query("[thinger]").addContent("...", "first");
+			// example:
+			//		adds a header before each element of the list
+			//	|	dojo.query(".note").addContent("<h4>NOTE:</h4>", "before");
+			// example:
+			//		add a clone of a DOM node to the end of every element in
+			//		the list, removing it from its existing parent.
+			//	|	dojo.query(".note").addContent(dojo.byId("foo"));
+			// example:
+			//		Append nodes from a templatized string.
+			// |	dojo.require("dojo.string");
+			// |	dojo.query(".note").addContent({
+			// |		template: '<b>${id}: </b><span>${name}</span>',
+			// |		id: "user332",
+			// |		name: "Mr. Anderson"
+			// |	});
+			// example:
+			//		Append nodes from a templatized string that also has widgets parsed.
+			// |	dojo.require("dojo.string");
+			// |	dojo.require("dojo.parser");
+			// |	var notes = dojo.query(".note").addContent({
+			// |		template: '<button dojoType="dijit/form/Button">${text}</button>',
+			// |		parse: true,
+			// |		text: "Send"
+			// |	});
+			content = this._normalize(content, this[0]);
+			for(var i = 0, node; (node = this[i]); i++){
+				if(content.length){
+					this._place(content, node, position, i > 0);
+				}else{
+					// if it is an empty array, we empty the target node
+					domCtr.empty(node);
+				}
+			}
+			return this; // dojo/NodeList
+		}
+	});
+
+	return NodeList;
+});

debian/missing-sources/dojo/Stateful.js

@@ -0,0 +1,213 @@
+define(["./_base/declare", "./_base/lang", "./_base/array", "./when"], function(declare, lang, array, when){
+	// module:
+	//		dojo/Stateful
+
+return declare("dojo.Stateful", null, {
+	// summary:
+	//		Base class for objects that provide named properties with optional getter/setter
+	//		control and the ability to watch for property changes
+	//
+	//		The class also provides the functionality to auto-magically manage getters
+	//		and setters for object attributes/properties.
+	//		
+	//		Getters and Setters should follow the format of _xxxGetter or _xxxSetter where 
+	//		the xxx is a name of the attribute to handle.  So an attribute of "foo" 
+	//		would have a custom getter of _fooGetter and a custom setter of _fooSetter.
+	//
+	// example:
+	//	|	var obj = new dojo.Stateful();
+	//	|	obj.watch("foo", function(){
+	//	|		console.log("foo changed to " + this.get("foo"));
+	//	|	});
+	//	|	obj.set("foo","bar");
+
+	// _attrPairNames: Hash
+	//		Used across all instances a hash to cache attribute names and their getter 
+	//		and setter names.
+	_attrPairNames: {},
+
+	_getAttrNames: function(name){
+		// summary:
+		//		Helper function for get() and set().
+		//		Caches attribute name values so we don't do the string ops every time.
+		// tags:
+		//		private
+
+		var apn = this._attrPairNames;
+		if(apn[name]){ return apn[name]; }
+		return (apn[name] = {
+			s: "_" + name + "Setter",
+			g: "_" + name + "Getter"
+		});
+	},
+
+	postscript: function(/*Object?*/ params){
+		// Automatic setting of params during construction
+		if (params){ this.set(params); }
+	},
+
+	_get: function(name, names){
+		// summary:
+		//		Private function that does a get based off a hash of names
+		// names:
+		//		Hash of names of custom attributes
+		return typeof this[names.g] === "function" ? this[names.g]() : this[name];
+	},
+	get: function(/*String*/name){
+		// summary:
+		//		Get a property on a Stateful instance.
+		// name:
+		//		The property to get.
+		// returns:
+		//		The property value on this Stateful instance.
+		// description:
+		//		Get a named property on a Stateful object. The property may
+		//		potentially be retrieved via a getter method in subclasses. In the base class
+		//		this just retrieves the object's property.
+		//		For example:
+		//	|	stateful = new dojo.Stateful({foo: 3});
+		//	|	stateful.get("foo") // returns 3
+		//	|	stateful.foo // returns 3
+
+		return this._get(name, this._getAttrNames(name)); //Any
+	},
+	set: function(/*String*/name, /*Object*/value){
+		// summary:
+		//		Set a property on a Stateful instance
+		// name:
+		//		The property to set.
+		// value:
+		//		The value to set in the property.
+		// returns:
+		//		The function returns this dojo.Stateful instance.
+		// description:
+		//		Sets named properties on a stateful object and notifies any watchers of
+		//		the property. A programmatic setter may be defined in subclasses.
+		//		For example:
+		//	|	stateful = new dojo.Stateful();
+		//	|	stateful.watch(function(name, oldValue, value){
+		//	|		// this will be called on the set below
+		//	|	}
+		//	|	stateful.set(foo, 5);
+		//
+		//	set() may also be called with a hash of name/value pairs, ex:
+		//	|	myObj.set({
+		//	|		foo: "Howdy",
+		//	|		bar: 3
+		//	|	})
+		//	This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
+
+		// If an object is used, iterate through object
+		if(typeof name === "object"){
+			for(var x in name){
+				if(name.hasOwnProperty(x) && x !="_watchCallbacks"){
+					this.set(x, name[x]);
+				}
+			}
+			return this;
+		}
+
+		var names = this._getAttrNames(name),
+			oldValue = this._get(name, names),
+			setter = this[names.s],
+			result;
+		if(typeof setter === "function"){
+			// use the explicit setter
+			result = setter.apply(this, Array.prototype.slice.call(arguments, 1));
+		}else{
+			// no setter so set attribute directly
+			this[name] = value;
+		}
+		if(this._watchCallbacks){
+			var self = this;
+			// If setter returned a promise, wait for it to complete, otherwise call watches immediatly
+			when(result, function(){
+				self._watchCallbacks(name, oldValue, value);
+			});
+		}
+		return this; // dojo/Stateful
+	},
+	_changeAttrValue: function(name, value){
+		// summary:
+		//		Internal helper for directly changing an attribute value.
+		//
+		// name: String
+		//		The property to set.
+		// value: Mixed
+		//		The value to set in the property.
+		//
+		// description:
+		//		Directly change the value of an attribute on an object, bypassing any 
+		//		accessor setter.  Also handles the calling of watch and emitting events. 
+		//		It is designed to be used by descendent class when there are two values 
+		//		of attributes that are linked, but calling .set() is not appropriate.
+
+		var oldValue = this.get(name);
+		this[name] = value;
+		if(this._watchCallbacks){
+			this._watchCallbacks(name, oldValue, value);
+		}
+		return this; // dojo/Stateful
+	},
+	watch: function(/*String?*/name, /*Function*/callback){
+		// summary:
+		//		Watches a property for changes
+		// name:
+		//		Indicates the property to watch. This is optional (the callback may be the
+		//		only parameter), and if omitted, all the properties will be watched
+		// returns:
+		//		An object handle for the watch. The unwatch method of this object
+		//		can be used to discontinue watching this property:
+		//		|	var watchHandle = obj.watch("foo", callback);
+		//		|	watchHandle.unwatch(); // callback won't be called now
+		// callback:
+		//		The function to execute when the property changes. This will be called after
+		//		the property has been changed. The callback will be called with the |this|
+		//		set to the instance, the first argument as the name of the property, the
+		//		second argument as the old value and the third argument as the new value.
+
+		var callbacks = this._watchCallbacks;
+		if(!callbacks){
+			var self = this;
+			callbacks = this._watchCallbacks = function(name, oldValue, value, ignoreCatchall){
+				var notify = function(propertyCallbacks){
+					if(propertyCallbacks){
+						propertyCallbacks = propertyCallbacks.slice();
+						for(var i = 0, l = propertyCallbacks.length; i < l; i++){
+							propertyCallbacks[i].call(self, name, oldValue, value);
+						}
+					}
+				};
+				notify(callbacks['_' + name]);
+				if(!ignoreCatchall){
+					notify(callbacks["*"]); // the catch-all
+				}
+			}; // we use a function instead of an object so it will be ignored by JSON conversion
+		}
+		if(!callback && typeof name === "function"){
+			callback = name;
+			name = "*";
+		}else{
+			// prepend with dash to prevent name conflicts with function (like "name" property)
+			name = '_' + name;
+		}
+		var propertyCallbacks = callbacks[name];
+		if(typeof propertyCallbacks !== "object"){
+			propertyCallbacks = callbacks[name] = [];
+		}
+		propertyCallbacks.push(callback);
+
+		// TODO: Remove unwatch in 2.0
+		var handle = {};
+		handle.unwatch = handle.remove = function(){
+			var index = array.indexOf(propertyCallbacks, callback);
+			if(index > -1){
+				propertyCallbacks.splice(index, 1);
+			}
+		};
+		return handle; //Object
+	}
+
+});
+
+});

debian/missing-sources/dojo/_base/Deferred.js

@@ -0,0 +1,383 @@
+define([
+	"./kernel",
+	"../Deferred",
+	"../promise/Promise",
+	"../errors/CancelError",
+	"../has",
+	"./lang",
+	"../when"
+], function(dojo, NewDeferred, Promise, CancelError, has, lang, when){
+	// module:
+	//		dojo/_base/Deferred
+
+	var mutator = function(){};
+	var freeze = Object.freeze || function(){};
+	// A deferred provides an API for creating and resolving a promise.
+	var Deferred = dojo.Deferred = function(/*Function?*/ canceller){
+		// summary:
+		//		Deprecated.   This module defines the legacy dojo/_base/Deferred API.
+		//		New code should use dojo/Deferred instead.
+		// description:
+		//		The Deferred API is based on the concept of promises that provide a
+		//		generic interface into the eventual completion of an asynchronous action.
+		//		The motivation for promises fundamentally is about creating a
+		//		separation of concerns that allows one to achieve the same type of
+		//		call patterns and logical data flow in asynchronous code as can be
+		//		achieved in synchronous code. Promises allows one
+		//		to be able to call a function purely with arguments needed for
+		//		execution, without conflating the call with concerns of whether it is
+		//		sync or async. One shouldn't need to alter a call's arguments if the
+		//		implementation switches from sync to async (or vice versa). By having
+		//		async functions return promises, the concerns of making the call are
+		//		separated from the concerns of asynchronous interaction (which are
+		//		handled by the promise).
+		//
+		//		The Deferred is a type of promise that provides methods for fulfilling the
+		//		promise with a successful result or an error. The most important method for
+		//		working with Dojo's promises is the then() method, which follows the
+		//		CommonJS proposed promise API. An example of using a Dojo promise:
+		//
+		//		|	var resultingPromise = someAsyncOperation.then(function(result){
+		//		|		... handle result ...
+		//		|	},
+		//		|	function(error){
+		//		|		... handle error ...
+		//		|	});
+		//
+		//		The .then() call returns a new promise that represents the result of the
+		//		execution of the callback. The callbacks will never affect the original promises value.
+		//
+		//		The Deferred instances also provide the following functions for backwards compatibility:
+		//
+		//		- addCallback(handler)
+		//		- addErrback(handler)
+		//		- callback(result)
+		//		- errback(result)
+		//
+		//		Callbacks are allowed to return promises themselves, so
+		//		you can build complicated sequences of events with ease.
+		//
+		//		The creator of the Deferred may specify a canceller.  The canceller
+		//		is a function that will be called if Deferred.cancel is called
+		//		before the Deferred fires. You can use this to implement clean
+		//		aborting of an XMLHttpRequest, etc. Note that cancel will fire the
+		//		deferred with a CancelledError (unless your canceller returns
+		//		another kind of error), so the errbacks should be prepared to
+		//		handle that error for cancellable Deferreds.
+		// example:
+		//	|	var deferred = new Deferred();
+		//	|	setTimeout(function(){ deferred.callback({success: true}); }, 1000);
+		//	|	return deferred;
+		// example:
+		//		Deferred objects are often used when making code asynchronous. It
+		//		may be easiest to write functions in a synchronous manner and then
+		//		split code using a deferred to trigger a response to a long-lived
+		//		operation. For example, instead of register a callback function to
+		//		denote when a rendering operation completes, the function can
+		//		simply return a deferred:
+		//
+		//		|	// callback style:
+		//		|	function renderLotsOfData(data, callback){
+		//		|		var success = false
+		//		|		try{
+		//		|			for(var x in data){
+		//		|				renderDataitem(data[x]);
+		//		|			}
+		//		|			success = true;
+		//		|		}catch(e){ }
+		//		|		if(callback){
+		//		|			callback(success);
+		//		|		}
+		//		|	}
+		//
+		//		|	// using callback style
+		//		|	renderLotsOfData(someDataObj, function(success){
+		//		|		// handles success or failure
+		//		|		if(!success){
+		//		|			promptUserToRecover();
+		//		|		}
+		//		|	});
+		//		|	// NOTE: no way to add another callback here!!
+		// example:
+		//		Using a Deferred doesn't simplify the sending code any, but it
+		//		provides a standard interface for callers and senders alike,
+		//		providing both with a simple way to service multiple callbacks for
+		//		an operation and freeing both sides from worrying about details
+		//		such as "did this get called already?". With Deferreds, new
+		//		callbacks can be added at any time.
+		//
+		//		|	// Deferred style:
+		//		|	function renderLotsOfData(data){
+		//		|		var d = new Deferred();
+		//		|		try{
+		//		|			for(var x in data){
+		//		|				renderDataitem(data[x]);
+		//		|			}
+		//		|			d.callback(true);
+		//		|		}catch(e){
+		//		|			d.errback(new Error("rendering failed"));
+		//		|		}
+		//		|		return d;
+		//		|	}
+		//
+		//		|	// using Deferred style
+		//		|	renderLotsOfData(someDataObj).then(null, function(){
+		//		|		promptUserToRecover();
+		//		|	});
+		//		|	// NOTE: addErrback and addCallback both return the Deferred
+		//		|	// again, so we could chain adding callbacks or save the
+		//		|	// deferred for later should we need to be notified again.
+		// example:
+		//		In this example, renderLotsOfData is synchronous and so both
+		//		versions are pretty artificial. Putting the data display on a
+		//		timeout helps show why Deferreds rock:
+		//
+		//		|	// Deferred style and async func
+		//		|	function renderLotsOfData(data){
+		//		|		var d = new Deferred();
+		//		|		setTimeout(function(){
+		//		|			try{
+		//		|				for(var x in data){
+		//		|					renderDataitem(data[x]);
+		//		|				}
+		//		|				d.callback(true);
+		//		|			}catch(e){
+		//		|				d.errback(new Error("rendering failed"));
+		//		|			}
+		//		|		}, 100);
+		//		|		return d;
+		//		|	}
+		//
+		//		|	// using Deferred style
+		//		|	renderLotsOfData(someDataObj).then(null, function(){
+		//		|		promptUserToRecover();
+		//		|	});
+		//
+		//		Note that the caller doesn't have to change his code at all to
+		//		handle the asynchronous case.
+
+		var result, finished, canceled, fired, isError, head, nextListener;
+		var promise = (this.promise = new Promise());
+
+		function complete(value){
+			if(finished){
+				throw new Error("This deferred has already been resolved");
+			}
+			result = value;
+			finished = true;
+			notify();
+		}
+		function notify(){
+			var mutated;
+			while(!mutated && nextListener){
+				var listener = nextListener;
+				nextListener = nextListener.next;
+				if((mutated = (listener.progress == mutator))){ // assignment and check
+					finished = false;
+				}
+
+				var func = (isError ? listener.error : listener.resolved);
+				if(has("config-useDeferredInstrumentation")){
+					if(isError && NewDeferred.instrumentRejected){
+						NewDeferred.instrumentRejected(result, !!func);
+					}
+				}
+				if(func){
+					try{
+						var newResult = func(result);
+						if (newResult && typeof newResult.then === "function"){
+							newResult.then(lang.hitch(listener.deferred, "resolve"), lang.hitch(listener.deferred, "reject"), lang.hitch(listener.deferred, "progress"));
+							continue;
+						}
+						var unchanged = mutated && newResult === undefined;
+						if(mutated && !unchanged){
+							isError = newResult instanceof Error;
+						}
+						listener.deferred[unchanged && isError ? "reject" : "resolve"](unchanged ? result : newResult);
+					}catch(e){
+						listener.deferred.reject(e);
+					}
+				}else{
+					if(isError){
+						listener.deferred.reject(result);
+					}else{
+						listener.deferred.resolve(result);
+					}
+				}
+			}
+		}
+
+		this.isResolved = promise.isResolved = function(){
+			// summary:
+			//		Checks whether the deferred has been resolved.
+			// returns: Boolean
+
+			return fired == 0;
+		};
+
+		this.isRejected = promise.isRejected = function(){
+			// summary:
+			//		Checks whether the deferred has been rejected.
+			// returns: Boolean
+
+			return fired == 1;
+		};
+
+		this.isFulfilled = promise.isFulfilled = function(){
+			// summary:
+			//		Checks whether the deferred has been resolved or rejected.
+			// returns: Boolean
+
+			return fired >= 0;
+		};
+
+		this.isCanceled = promise.isCanceled = function(){
+			// summary:
+			//		Checks whether the deferred has been canceled.
+			// returns: Boolean
+
+			return canceled;
+		};
+
+		// calling resolve will resolve the promise
+		this.resolve = this.callback = function(value){
+			// summary:
+			//		Fulfills the Deferred instance successfully with the provide value
+			this.fired = fired = 0;
+			this.results = [value, null];
+			complete(value);
+		};
+
+
+		// calling error will indicate that the promise failed
+		this.reject = this.errback = function(error){
+			// summary:
+			//		Fulfills the Deferred instance as an error with the provided error
+			isError = true;
+			this.fired = fired = 1;
+			if(has("config-useDeferredInstrumentation")){
+				if(NewDeferred.instrumentRejected){
+					NewDeferred.instrumentRejected(error, !!nextListener);
+				}
+			}
+			complete(error);
+			this.results = [null, error];
+		};
+		// call progress to provide updates on the progress on the completion of the promise
+		this.progress = function(update){
+			// summary:
+			//		Send progress events to all listeners
+			var listener = nextListener;
+			while(listener){
+				var progress = listener.progress;
+				progress && progress(update);
+				listener = listener.next;
+			}
+		};
+		this.addCallbacks = function(callback, errback){
+			// summary:
+			//		Adds callback and error callback for this deferred instance.
+			// callback: Function?
+			//		The callback attached to this deferred object.
+			// errback: Function?
+			//		The error callback attached to this deferred object.
+			// returns:
+			//		Returns this deferred object.
+			this.then(callback, errback, mutator);
+			return this;	// Deferred
+		};
+		// provide the implementation of the promise
+		promise.then = this.then = function(/*Function?*/resolvedCallback, /*Function?*/errorCallback, /*Function?*/progressCallback){
+			// summary:
+			//		Adds a fulfilledHandler, errorHandler, and progressHandler to be called for
+			//		completion of a promise. The fulfilledHandler is called when the promise
+			//		is fulfilled. The errorHandler is called when a promise fails. The
+			//		progressHandler is called for progress events. All arguments are optional
+			//		and non-function values are ignored. The progressHandler is not only an
+			//		optional argument, but progress events are purely optional. Promise
+			//		providers are not required to ever create progress events.
+			//
+			//		This function will return a new promise that is fulfilled when the given
+			//		fulfilledHandler or errorHandler callback is finished. This allows promise
+			//		operations to be chained together. The value returned from the callback
+			//		handler is the fulfillment value for the returned promise. If the callback
+			//		throws an error, the returned promise will be moved to failed state.
+			//
+			// returns:
+			//		Returns a new promise that represents the result of the
+			//		execution of the callback. The callbacks will never affect the original promises value.
+			// example:
+			//		An example of using a CommonJS compliant promise:
+			//		|	asyncComputeTheAnswerToEverything().
+			//		|		then(addTwo).
+			//		|		then(printResult, onError);
+			//		|	>44
+			//
+			var returnDeferred = progressCallback == mutator ? this : new Deferred(promise.cancel);
+			var listener = {
+				resolved: resolvedCallback,
+				error: errorCallback,
+				progress: progressCallback,
+				deferred: returnDeferred
+			};
+			if(nextListener){
+				head = head.next = listener;
+			}
+			else{
+				nextListener = head = listener;
+			}
+			if(finished){
+				notify();
+			}
+			return returnDeferred.promise; // Promise
+		};
+		var deferred = this;
+		promise.cancel = this.cancel = function(){
+			// summary:
+			//		Cancels the asynchronous operation
+			if(!finished){
+				var error = canceller && canceller(deferred);
+				if(!finished){
+					if (!(error instanceof Error)){
+						error = new CancelError(error);
+					}
+					error.log = false;
+					deferred.reject(error);
+				}
+			}
+			canceled = true;
+		};
+		freeze(promise);
+	};
+	lang.extend(Deferred, {
+		addCallback: function(/*Function*/ callback){
+			// summary:
+			//		Adds successful callback for this deferred instance.
+			// returns:
+			//		Returns this deferred object.
+			return this.addCallbacks(lang.hitch.apply(dojo, arguments));	// Deferred
+		},
+
+		addErrback: function(/*Function*/ errback){
+			// summary:
+			//		Adds error callback for this deferred instance.
+			// returns:
+			//		Returns this deferred object.
+			return this.addCallbacks(null, lang.hitch.apply(dojo, arguments));	// Deferred
+		},
+
+		addBoth: function(/*Function*/ callback){
+			// summary:
+			//		Add handler as both successful callback and error callback for this deferred instance.
+			// returns:
+			//		Returns this deferred object.
+			var enclosed = lang.hitch.apply(dojo, arguments);
+			return this.addCallbacks(enclosed, enclosed);	// Deferred
+		},
+		fired: -1
+	});
+
+	Deferred.when = dojo.when = when;
+
+	return Deferred;
+});

debian/missing-sources/dojo/_base/array.js

@@ -0,0 +1,350 @@
+define(["./kernel", "../has", "./lang"], function(dojo, has, lang){
+	// module:
+	//		dojo/_base/array
+
+	// our old simple function builder stuff
+	var cache = {}, u;
+
+	function buildFn(fn){
+		return cache[fn] = new Function("item", "index", "array", fn); // Function
+	}
+	// magic snippet: if(typeof fn == "string") fn = cache[fn] || buildFn(fn);
+
+	// every & some
+
+	function everyOrSome(some){
+		var every = !some;
+		return function(a, fn, o){
+			var i = 0, l = a && a.length || 0, result;
+			if(l && typeof a == "string") a = a.split("");
+			if(typeof fn == "string") fn = cache[fn] || buildFn(fn);
+			if(o){
+				for(; i < l; ++i){
+					result = !fn.call(o, a[i], i, a);
+					if(some ^ result){
+						return !result;
+					}
+				}
+			}else{
+				for(; i < l; ++i){
+					result = !fn(a[i], i, a);
+					if(some ^ result){
+						return !result;
+					}
+				}
+			}
+			return every; // Boolean
+		};
+	}
+
+	// indexOf, lastIndexOf
+
+	function index(up){
+		var delta = 1, lOver = 0, uOver = 0;
+		if(!up){
+			delta = lOver = uOver = -1;
+		}
+		return function(a, x, from, last){
+			if(last && delta > 0){
+				// TODO: why do we use a non-standard signature? why do we need "last"?
+				return array.lastIndexOf(a, x, from);
+			}
+			var l = a && a.length || 0, end = up ? l + uOver : lOver, i;
+			if(from === u){
+				i = up ? lOver : l + uOver;
+			}else{
+				if(from < 0){
+					i = l + from;
+					if(i < 0){
+						i = lOver;
+					}
+				}else{
+					i = from >= l ? l + uOver : from;
+				}
+			}
+			if(l && typeof a == "string") a = a.split("");
+			for(; i != end; i += delta){
+				if(a[i] == x){
+					return i; // Number
+				}
+			}
+			return -1; // Number
+		};
+	}
+
+	var array = {
+		// summary:
+		//		The Javascript v1.6 array extensions.
+
+		every: everyOrSome(false),
+		/*=====
+		 every: function(arr, callback, thisObject){
+			 // summary:
+			 //		Determines whether or not every item in arr satisfies the
+			 //		condition implemented by callback.
+			 // arr: Array|String
+			 //		the array to iterate on. If a string, operates on individual characters.
+			 // callback: Function|String
+			 //		a function is invoked with three arguments: item, index,
+			 //		and array and returns true if the condition is met.
+			 // thisObject: Object?
+			 //		may be used to scope the call to callback
+			 // returns: Boolean
+			 // description:
+			 //		This function corresponds to the JavaScript 1.6 Array.every() method, with one difference: when
+			 //		run over sparse arrays, this implementation passes the "holes" in the sparse array to
+			 //		the callback function with a value of undefined. JavaScript 1.6's every skips the holes in the sparse array.
+			 //		For more details, see:
+			 //		https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/every
+			 // example:
+			 //	|	// returns false
+			 //	|	array.every([1, 2, 3, 4], function(item){ return item>1; });
+			 // example:
+			 //	|	// returns true
+			 //	|	array.every([1, 2, 3, 4], function(item){ return item>0; });
+		 },
+		 =====*/
+
+		some: everyOrSome(true),
+		/*=====
+		some: function(arr, callback, thisObject){
+			// summary:
+			//		Determines whether or not any item in arr satisfies the
+			//		condition implemented by callback.
+			// arr: Array|String
+			//		the array to iterate over. If a string, operates on individual characters.
+			// callback: Function|String
+			//		a function is invoked with three arguments: item, index,
+			//		and array and returns true if the condition is met.
+			// thisObject: Object?
+			//		may be used to scope the call to callback
+			// returns: Boolean
+			// description:
+			//		This function corresponds to the JavaScript 1.6 Array.some() method, with one difference: when
+			//		run over sparse arrays, this implementation passes the "holes" in the sparse array to
+			//		the callback function with a value of undefined. JavaScript 1.6's some skips the holes in the sparse array.
+			//		For more details, see:
+			//		https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/some
+			// example:
+			//	| // is true
+			//	| array.some([1, 2, 3, 4], function(item){ return item>1; });
+			// example:
+			//	| // is false
+			//	| array.some([1, 2, 3, 4], function(item){ return item<1; });
+		},
+		=====*/
+
+		indexOf: index(true),
+		/*=====
+		indexOf: function(arr, value, fromIndex, findLast){
+			// summary:
+			//		locates the first index of the provided value in the
+			//		passed array. If the value is not found, -1 is returned.
+			// description:
+			//		This method corresponds to the JavaScript 1.6 Array.indexOf method, with two differences:
+			//
+			//		1. when run over sparse arrays, the Dojo function invokes the callback for every index
+			//		   whereas JavaScript 1.6's indexOf skips the holes in the sparse array.
+			//		2. uses equality (==) rather than strict equality (===)
+			//
+			//		For details on this method, see:
+			//		https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/indexOf
+			// arr: Array
+			// value: Object
+			// fromIndex: Integer?
+			// findLast: Boolean?
+			//		Makes indexOf() work like lastIndexOf().  Used internally; not meant for external usage.
+			// returns: Number
+		},
+		=====*/
+
+		lastIndexOf: index(false),
+		/*=====
+		lastIndexOf: function(arr, value, fromIndex){
+			// summary:
+			//		locates the last index of the provided value in the passed
+			//		array. If the value is not found, -1 is returned.
+			// description:
+		 	//		This method corresponds to the JavaScript 1.6 Array.lastIndexOf method, with two differences:
+		 	//
+		 	//		1. when run over sparse arrays, the Dojo function invokes the callback for every index
+		 	//		   whereas JavaScript 1.6's lasIndexOf skips the holes in the sparse array.
+		 	//		2. uses equality (==) rather than strict equality (===)
+		 	//
+		 	//		For details on this method, see:
+		 	//		https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/lastIndexOf
+			// arr: Array,
+			// value: Object,
+			// fromIndex: Integer?
+			// returns: Number
+		},
+		=====*/
+
+		forEach: function(arr, callback, thisObject){
+			// summary:
+			//		for every item in arr, callback is invoked. Return values are ignored.
+			//		If you want to break out of the loop, consider using array.every() or array.some().
+			//		forEach does not allow breaking out of the loop over the items in arr.
+			// arr:
+			//		the array to iterate over. If a string, operates on individual characters.
+			// callback:
+			//		a function is invoked with three arguments: item, index, and array
+			// thisObject:
+			//		may be used to scope the call to callback
+			// description:
+			//		This function corresponds to the JavaScript 1.6 Array.forEach() method, with one difference: when
+			//		run over sparse arrays, this implementation passes the "holes" in the sparse array to
+			//		the callback function with a value of undefined. JavaScript 1.6's forEach skips the holes in the sparse array.
+			//		For more details, see:
+			//		https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/forEach
+			// example:
+			//	| // log out all members of the array:
+			//	| array.forEach(
+			//	|		[ "thinger", "blah", "howdy", 10 ],
+			//	|		function(item){
+			//	|			console.log(item);
+			//	|		}
+			//	| );
+			// example:
+			//	| // log out the members and their indexes
+			//	| array.forEach(
+			//	|		[ "thinger", "blah", "howdy", 10 ],
+			//	|		function(item, idx, arr){
+			//	|			console.log(item, "at index:", idx);
+			//	|		}
+			//	| );
+			// example:
+			//	| // use a scoped object member as the callback
+			//	|
+			//	| var obj = {
+			//	|		prefix: "logged via obj.callback:",
+			//	|		callback: function(item){
+			//	|			console.log(this.prefix, item);
+			//	|		}
+			//	| };
+			//	|
+			//	| // specifying the scope function executes the callback in that scope
+			//	| array.forEach(
+			//	|		[ "thinger", "blah", "howdy", 10 ],
+			//	|		obj.callback,
+			//	|		obj
+			//	| );
+			//	|
+			//	| // alternately, we can accomplish the same thing with lang.hitch()
+			//	| array.forEach(
+			//	|		[ "thinger", "blah", "howdy", 10 ],
+			//	|		lang.hitch(obj, "callback")
+			//	| );
+			// arr: Array|String
+			// callback: Function|String
+			// thisObject: Object?
+
+			var i = 0, l = arr && arr.length || 0;
+			if(l && typeof arr == "string") arr = arr.split("");
+			if(typeof callback == "string") callback = cache[callback] || buildFn(callback);
+			if(thisObject){
+				for(; i < l; ++i){
+					callback.call(thisObject, arr[i], i, arr);
+				}
+			}else{
+				for(; i < l; ++i){
+					callback(arr[i], i, arr);
+				}
+			}
+		},
+
+		map: function(arr, callback, thisObject, Ctr){
+			// summary:
+			//		applies callback to each element of arr and returns
+			//		an Array with the results
+			// arr: Array|String
+			//		the array to iterate on. If a string, operates on
+			//		individual characters.
+			// callback: Function|String
+			//		a function is invoked with three arguments, (item, index,
+			//		array),	 and returns a value
+			// thisObject: Object?
+			//		may be used to scope the call to callback
+			// returns: Array
+			// description:
+			//		This function corresponds to the JavaScript 1.6 Array.map() method, with one difference: when
+			//		run over sparse arrays, this implementation passes the "holes" in the sparse array to
+			//		the callback function with a value of undefined. JavaScript 1.6's map skips the holes in the sparse array.
+			//		For more details, see:
+			//		https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/map
+			// example:
+			//	| // returns [2, 3, 4, 5]
+			//	| array.map([1, 2, 3, 4], function(item){ return item+1 });
+
+			// TODO: why do we have a non-standard signature here? do we need "Ctr"?
+			var i = 0, l = arr && arr.length || 0, out = new (Ctr || Array)(l);
+			if(l && typeof arr == "string") arr = arr.split("");
+			if(typeof callback == "string") callback = cache[callback] || buildFn(callback);
+			if(thisObject){
+				for(; i < l; ++i){
+					out[i] = callback.call(thisObject, arr[i], i, arr);
+				}
+			}else{
+				for(; i < l; ++i){
+					out[i] = callback(arr[i], i, arr);
+				}
+			}
+			return out; // Array
+		},
+
+		filter: function(arr, callback, thisObject){
+			// summary:
+			//		Returns a new Array with those items from arr that match the
+			//		condition implemented by callback.
+			// arr: Array
+			//		the array to iterate over.
+			// callback: Function|String
+			//		a function that is invoked with three arguments (item,
+			//		index, array). The return of this function is expected to
+			//		be a boolean which determines whether the passed-in item
+			//		will be included in the returned array.
+			// thisObject: Object?
+			//		may be used to scope the call to callback
+			// returns: Array
+			// description:
+			//		This function corresponds to the JavaScript 1.6 Array.filter() method, with one difference: when
+			//		run over sparse arrays, this implementation passes the "holes" in the sparse array to
+			//		the callback function with a value of undefined. JavaScript 1.6's filter skips the holes in the sparse array.
+			//		For more details, see:
+			//		https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/filter
+			// example:
+			//	| // returns [2, 3, 4]
+			//	| array.filter([1, 2, 3, 4], function(item){ return item>1; });
+
+			// TODO: do we need "Ctr" here like in map()?
+			var i = 0, l = arr && arr.length || 0, out = [], value;
+			if(l && typeof arr == "string") arr = arr.split("");
+			if(typeof callback == "string") callback = cache[callback] || buildFn(callback);
+			if(thisObject){
+				for(; i < l; ++i){
+					value = arr[i];
+					if(callback.call(thisObject, value, i, arr)){
+						out.push(value);
+					}
+				}
+			}else{
+				for(; i < l; ++i){
+					value = arr[i];
+					if(callback(value, i, arr)){
+						out.push(value);
+					}
+				}
+			}
+			return out; // Array
+		},
+
+		clearCache: function(){
+			cache = {};
+		}
+	};
+
+
+	has("extend-dojo") && lang.mixin(dojo, array);
+
+	return array;
+});

debian/missing-sources/dojo/_base/config.js

@@ -0,0 +1,193 @@
+define(["../has", "require"], function(has, require){
+	// module:
+	//		dojo/_base/config
+
+/*=====
+return {
+	// summary:
+	//		This module defines the user configuration during bootstrap.
+	// description:
+	//		By defining user configuration as a module value, an entire configuration can be specified in a build,
+	//		thereby eliminating the need for sniffing and or explicitly setting in the global variable dojoConfig.
+	//		Also, when multiple instances of dojo exist in a single application, each will necessarily be located
+	//		at an unique absolute module identifier as given by the package configuration. Implementing configuration
+	//		as a module allows for specifying unique, per-instance configurations.
+	// example:
+	//		Create a second instance of dojo with a different, instance-unique configuration (assume the loader and
+	//		dojo.js are already loaded).
+	//		|	// specify a configuration that creates a new instance of dojo at the absolute module identifier "myDojo"
+	//		|	require({
+	//		|		packages:[{
+	//		|			name:"myDojo",
+	//		|			location:".", //assume baseUrl points to dojo.js
+	//		|		}]
+	//		|	});
+	//		|
+	//		|	// specify a configuration for the myDojo instance
+	//		|	define("myDojo/config", {
+	//		|		// normal configuration variables go here, e.g.,
+	//		|		locale:"fr-ca"
+	//		|	});
+	//		|
+	//		|	// load and use the new instance of dojo
+	//		|	require(["myDojo"], function(dojo){
+	//		|		// dojo is the new instance of dojo
+	//		|		// use as required
+	//		|	});
+
+	// isDebug: Boolean
+	//		Defaults to `false`. If set to `true`, ensures that Dojo provides
+	//		extended debugging feedback via Firebug. If Firebug is not available
+	//		on your platform, setting `isDebug` to `true` will force Dojo to
+	//		pull in (and display) the version of Firebug Lite which is
+	//		integrated into the Dojo distribution, thereby always providing a
+	//		debugging/logging console when `isDebug` is enabled. Note that
+	//		Firebug's `console.*` methods are ALWAYS defined by Dojo. If
+	//		`isDebug` is false and you are on a platform without Firebug, these
+	//		methods will be defined as no-ops.
+	isDebug: false,
+
+	// locale: String
+	//		The locale to assume for loading localized resources in this page,
+	//		specified according to [RFC 3066](http://www.ietf.org/rfc/rfc3066.txt).
+	//		Must be specified entirely in lowercase, e.g. `en-us` and `zh-cn`.
+	//		See the documentation for `dojo.i18n` and `dojo.requireLocalization`
+	//		for details on loading localized resources. If no locale is specified,
+	//		Dojo assumes the locale of the user agent, according to `navigator.userLanguage`
+	//		or `navigator.language` properties.
+	locale: undefined,
+
+	// extraLocale: Array
+	//		No default value. Specifies additional locales whose
+	//		resources should also be loaded alongside the default locale when
+	//		calls to `dojo.requireLocalization()` are processed.
+	extraLocale: undefined,
+
+	// baseUrl: String
+	//		The directory in which `dojo.js` is located. Under normal
+	//		conditions, Dojo auto-detects the correct location from which it
+	//		was loaded. You may need to manually configure `baseUrl` in cases
+	//		where you have renamed `dojo.js` or in which `<base>` tags confuse
+	//		some browsers (e.g. IE 6). The variable `dojo.baseUrl` is assigned
+	//		either the value of `djConfig.baseUrl` if one is provided or the
+	//		auto-detected root if not. Other modules are located relative to
+	//		this path. The path should end in a slash.
+	baseUrl: undefined,
+
+	// modulePaths: [deprecated] Object
+	//		A map of module names to paths relative to `dojo.baseUrl`. The
+	//		key/value pairs correspond directly to the arguments which
+	//		`dojo.registerModulePath` accepts. Specifying
+	//		`djConfig.modulePaths = { "foo": "../../bar" }` is the equivalent
+	//		of calling `dojo.registerModulePath("foo", "../../bar");`. Multiple
+	//		modules may be configured via `djConfig.modulePaths`.
+	modulePaths: {},
+
+	// addOnLoad: Function|Array
+	//		Adds a callback via dojo/ready. Useful when Dojo is added after
+	//		the page loads and djConfig.afterOnLoad is true. Supports the same
+	//		arguments as dojo/ready. When using a function reference, use
+	//		`djConfig.addOnLoad = function(){};`. For object with function name use
+	//		`djConfig.addOnLoad = [myObject, "functionName"];` and for object with
+	//		function reference use
+	//		`djConfig.addOnLoad = [myObject, function(){}];`
+	addOnLoad: null,
+
+	// parseOnLoad: Boolean
+	//		Run the parser after the page is loaded
+	parseOnLoad: false,
+
+	// require: String[]
+	//		An array of module names to be loaded immediately after dojo.js has been included
+	//		in a page.
+	require: [],
+
+	// defaultDuration: Number
+	//		Default duration, in milliseconds, for wipe and fade animations within dijits.
+	//		Assigned to dijit.defaultDuration.
+	defaultDuration: 200,
+
+	// dojoBlankHtmlUrl: String
+	//		Used by some modules to configure an empty iframe. Used by dojo/io/iframe and
+	//		dojo/back, and dijit/popup support in IE where an iframe is needed to make sure native
+	//		controls do not bleed through the popups. Normally this configuration variable
+	//		does not need to be set, except when using cross-domain/CDN Dojo builds.
+	//		Save dojo/resources/blank.html to your domain and set `djConfig.dojoBlankHtmlUrl`
+	//		to the path on your domain your copy of blank.html.
+	dojoBlankHtmlUrl: undefined,
+
+	// ioPublish: Boolean?
+	//		Set this to true to enable publishing of topics for the different phases of
+	//		IO operations. Publishing is done via dojo/topic.publish(). See dojo/main.__IoPublish for a list
+	//		of topics that are published.
+	ioPublish: false,
+
+	// useCustomLogger: Anything?
+	//		If set to a value that evaluates to true such as a string or array and
+	//		isDebug is true and Firebug is not available or running, then it bypasses
+	//		the creation of Firebug Lite allowing you to define your own console object.
+	useCustomLogger: undefined,
+
+	// transparentColor: Array
+	//		Array containing the r, g, b components used as transparent color in dojo.Color;
+	//		if undefined, [255,255,255] (white) will be used.
+	transparentColor: undefined,
+	
+	// deps: Function|Array
+	//		Defines dependencies to be used before the loader has been loaded.
+	//		When provided, they cause the loader to execute require(deps, callback) 
+	//		once it has finished loading. Should be used with callback.
+	deps: undefined,
+	
+	// callback: Function|Array
+	//		Defines a callback to be used when dependencies are defined before 
+	//		the loader has been loaded. When provided, they cause the loader to 
+	//		execute require(deps, callback) once it has finished loading. 
+	//		Should be used with deps.
+	callback: undefined,
+	
+	// deferredInstrumentation: Boolean
+	//		Whether deferred instrumentation should be loaded or included
+	//		in builds.
+	deferredInstrumentation: true,
+
+	// useDeferredInstrumentation: Boolean|String
+	//		Whether the deferred instrumentation should be used.
+	//
+	//		* `"report-rejections"`: report each rejection as it occurs.
+	//		* `true` or `1` or `"report-unhandled-rejections"`: wait 1 second
+	//			in an attempt to detect unhandled rejections.
+	useDeferredInstrumentation: "report-unhandled-rejections"
+};
+=====*/
+
+	var result = {};
+	if(has("dojo-config-api")){
+		// must be the dojo loader; take a shallow copy of require.rawConfig
+		var src = require.rawConfig, p;
+		for(p in src){
+			result[p] = src[p];
+		}
+	}else{
+		var adviseHas = function(featureSet, prefix, booting){
+			for(p in featureSet){
+				p!="has" && has.add(prefix + p, featureSet[p], 0, booting);
+			}
+		};
+		result = has("dojo-loader") ?
+			// must be a built version of the dojo loader; all config stuffed in require.rawConfig
+			require.rawConfig :
+			// a foreign loader
+			this.dojoConfig || this.djConfig || {};
+		adviseHas(result, "config", 1);
+		adviseHas(result.has, "", 1);
+	}
+
+	if(!result.locale && typeof navigator != "undefined"){
+		// Default locale for browsers.
+		result.locale = (navigator.language || navigator.userLanguage).toLowerCase();
+	}
+
+	return result;
+});
+

debian/missing-sources/dojo/_base/connect.js

@@ -0,0 +1,374 @@
+define(["./kernel", "../on", "../topic", "../aspect", "./event", "../mouse", "./sniff", "./lang", "../keys"], function(dojo, on, hub, aspect, eventModule, mouse, has, lang){
+// module:
+//		dojo/_base/connect
+
+has.add("events-keypress-typed", function(){ // keypresses should only occur a printable character is hit
+	var testKeyEvent = {charCode: 0};
+	try{
+		testKeyEvent = document.createEvent("KeyboardEvent");
+		(testKeyEvent.initKeyboardEvent || testKeyEvent.initKeyEvent).call(testKeyEvent, "keypress", true, true, null, false, false, false, false, 9, 3);
+	}catch(e){}
+	return testKeyEvent.charCode == 0 && !has("opera");
+});
+
+function connect_(obj, event, context, method, dontFix){
+	method = lang.hitch(context, method);
+	if(!obj || !(obj.addEventListener || obj.attachEvent)){
+		// it is a not a DOM node and we are using the dojo.connect style of treating a
+		// method like an event, must go right to aspect
+		return aspect.after(obj || dojo.global, event, method, true);
+	}
+	if(typeof event == "string" && event.substring(0, 2) == "on"){
+		event = event.substring(2);
+	}
+	if(!obj){
+		obj = dojo.global;
+	}
+	if(!dontFix){
+		switch(event){
+			// dojo.connect has special handling for these event types
+			case "keypress":
+				event = keypress;
+				break;
+			case "mouseenter":
+				event = mouse.enter;
+				break;
+			case "mouseleave":
+				event = mouse.leave;
+				break;
+		}
+	}
+	return on(obj, event, method, dontFix);
+}
+
+var _punctMap = {
+	106:42,
+	111:47,
+	186:59,
+	187:43,
+	188:44,
+	189:45,
+	190:46,
+	191:47,
+	192:96,
+	219:91,
+	220:92,
+	221:93,
+	222:39,
+	229:113
+};
+var evtCopyKey = has("mac") ? "metaKey" : "ctrlKey";
+
+
+var _synthesizeEvent = function(evt, props){
+	var faux = lang.mixin({}, evt, props);
+	setKeyChar(faux);
+	// FIXME: would prefer to use lang.hitch: lang.hitch(evt, evt.preventDefault);
+	// but it throws an error when preventDefault is invoked on Safari
+	// does Event.preventDefault not support "apply" on Safari?
+	faux.preventDefault = function(){ evt.preventDefault(); };
+	faux.stopPropagation = function(){ evt.stopPropagation(); };
+	return faux;
+};
+function setKeyChar(evt){
+	evt.keyChar = evt.charCode ? String.fromCharCode(evt.charCode) : '';
+	evt.charOrCode = evt.keyChar || evt.keyCode;
+}
+var keypress;
+if(has("events-keypress-typed")){
+	// this emulates Firefox's keypress behavior where every keydown can correspond to a keypress
+	var _trySetKeyCode = function(e, code){
+		try{
+			// squelch errors when keyCode is read-only
+			// (e.g. if keyCode is ctrl or shift)
+			return (e.keyCode = code);
+		}catch(e){
+			return 0;
+		}
+	};
+	keypress = function(object, listener){
+		var keydownSignal = on(object, "keydown", function(evt){
+			// munge key/charCode
+			var k=evt.keyCode;
+			// These are Windows Virtual Key Codes
+			// http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winui/WinUI/WindowsUserInterface/UserInput/VirtualKeyCodes.asp
+			var unprintable = (k!=13) && k!=32 && (k!=27||!has("ie")) && (k<48||k>90) && (k<96||k>111) && (k<186||k>192) && (k<219||k>222) && k!=229;
+			// synthesize keypress for most unprintables and CTRL-keys
+			if(unprintable||evt.ctrlKey){
+				var c = unprintable ? 0 : k;
+				if(evt.ctrlKey){
+					if(k==3 || k==13){
+						return listener.call(evt.currentTarget, evt); // IE will post CTRL-BREAK, CTRL-ENTER as keypress natively
+					}else if(c>95 && c<106){
+						c -= 48; // map CTRL-[numpad 0-9] to ASCII
+					}else if((!evt.shiftKey)&&(c>=65&&c<=90)){
+						c += 32; // map CTRL-[A-Z] to lowercase
+					}else{
+						c = _punctMap[c] || c; // map other problematic CTRL combinations to ASCII
+					}
+				}
+				// simulate a keypress event
+				var faux = _synthesizeEvent(evt, {type: 'keypress', faux: true, charCode: c});
+				listener.call(evt.currentTarget, faux);
+				if(has("ie")){
+					_trySetKeyCode(evt, faux.keyCode);
+				}
+			}
+		});
+		var keypressSignal = on(object, "keypress", function(evt){
+			var c = evt.charCode;
+			c = c>=32 ? c : 0;
+			evt = _synthesizeEvent(evt, {charCode: c, faux: true});
+			return listener.call(this, evt);
+		});
+		return {
+			remove: function(){
+				keydownSignal.remove();
+				keypressSignal.remove();
+			}
+		};
+	};
+}else{
+	if(has("opera")){
+		keypress = function(object, listener){
+			return on(object, "keypress", function(evt){
+				var c = evt.which;
+				if(c==3){
+					c=99; // Mozilla maps CTRL-BREAK to CTRL-c
+				}
+				// can't trap some keys at all, like INSERT and DELETE
+				// there is no differentiating info between DELETE and ".", or INSERT and "-"
+				c = c<32 && !evt.shiftKey ? 0 : c;
+				if(evt.ctrlKey && !evt.shiftKey && c>=65 && c<=90){
+					// lowercase CTRL-[A-Z] keys
+					c += 32;
+				}
+				return listener.call(this, _synthesizeEvent(evt, { charCode: c }));
+			});
+		};
+	}else{
+		keypress = function(object, listener){
+			return on(object, "keypress", function(evt){
+				setKeyChar(evt);
+				return listener.call(this, evt);
+			});
+		};
+	}
+}
+
+var connect = {
+	// summary:
+	//		This module defines the dojo.connect API.
+	//		This modules also provides keyboard event handling helpers.
+	//		This module exports an extension event for emulating Firefox's keypress handling.
+	//		However, this extension event exists primarily for backwards compatibility and
+	//		is not recommended. WebKit and IE uses an alternate keypress handling (only
+	//		firing for printable characters, to distinguish from keydown events), and most
+	//		consider the WebKit/IE behavior more desirable.
+
+	_keypress:keypress,
+
+	connect:function(obj, event, context, method, dontFix){
+		// summary:
+		//		`dojo.connect` is a deprecated event handling and delegation method in
+		//		Dojo. It allows one function to "listen in" on the execution of
+		//		any other, triggering the second whenever the first is called. Many
+		//		listeners may be attached to a function, and source functions may
+		//		be either regular function calls or DOM events.
+		//
+		// description:
+		//		Connects listeners to actions, so that after event fires, a
+		//		listener is called with the same arguments passed to the original
+		//		function.
+		//
+		//		Since `dojo.connect` allows the source of events to be either a
+		//		"regular" JavaScript function or a DOM event, it provides a uniform
+		//		interface for listening to all the types of events that an
+		//		application is likely to deal with though a single, unified
+		//		interface. DOM programmers may want to think of it as
+		//		"addEventListener for everything and anything".
+		//
+		//		When setting up a connection, the `event` parameter must be a
+		//		string that is the name of the method/event to be listened for. If
+		//		`obj` is null, `kernel.global` is assumed, meaning that connections
+		//		to global methods are supported but also that you may inadvertently
+		//		connect to a global by passing an incorrect object name or invalid
+		//		reference.
+		//
+		//		`dojo.connect` generally is forgiving. If you pass the name of a
+		//		function or method that does not yet exist on `obj`, connect will
+		//		not fail, but will instead set up a stub method. Similarly, null
+		//		arguments may simply be omitted such that fewer than 4 arguments
+		//		may be required to set up a connection See the examples for details.
+		//
+		//		The return value is a handle that is needed to
+		//		remove this connection with `dojo.disconnect`.
+		//
+		// obj: Object?
+		//		The source object for the event function.
+		//		Defaults to `kernel.global` if null.
+		//		If obj is a DOM node, the connection is delegated
+		//		to the DOM event manager (unless dontFix is true).
+		//
+		// event: String
+		//		String name of the event function in obj.
+		//		I.e. identifies a property `obj[event]`.
+		//
+		// context: Object|null
+		//		The object that method will receive as "this".
+		//
+		//		If context is null and method is a function, then method
+		//		inherits the context of event.
+		//
+		//		If method is a string then context must be the source
+		//		object object for method (context[method]). If context is null,
+		//		kernel.global is used.
+		//
+		// method: String|Function
+		//		A function reference, or name of a function in context.
+		//		The function identified by method fires after event does.
+		//		method receives the same arguments as the event.
+		//		See context argument comments for information on method's scope.
+		//
+		// dontFix: Boolean?
+		//		If obj is a DOM node, set dontFix to true to prevent delegation
+		//		of this connection to the DOM event manager.
+		//
+		// example:
+		//		When obj.onchange(), do ui.update():
+		//	|	dojo.connect(obj, "onchange", ui, "update");
+		//	|	dojo.connect(obj, "onchange", ui, ui.update); // same
+		//
+		// example:
+		//		Using return value for disconnect:
+		//	|	var link = dojo.connect(obj, "onchange", ui, "update");
+		//	|	...
+		//	|	dojo.disconnect(link);
+		//
+		// example:
+		//		When onglobalevent executes, watcher.handler is invoked:
+		//	|	dojo.connect(null, "onglobalevent", watcher, "handler");
+		//
+		// example:
+		//		When ob.onCustomEvent executes, customEventHandler is invoked:
+		//	|	dojo.connect(ob, "onCustomEvent", null, "customEventHandler");
+		//	|	dojo.connect(ob, "onCustomEvent", "customEventHandler"); // same
+		//
+		// example:
+		//		When ob.onCustomEvent executes, customEventHandler is invoked
+		//		with the same scope (this):
+		//	|	dojo.connect(ob, "onCustomEvent", null, customEventHandler);
+		//	|	dojo.connect(ob, "onCustomEvent", customEventHandler); // same
+		//
+		// example:
+		//		When globalEvent executes, globalHandler is invoked
+		//		with the same scope (this):
+		//	|	dojo.connect(null, "globalEvent", null, globalHandler);
+		//	|	dojo.connect("globalEvent", globalHandler); // same
+
+		// normalize arguments
+		var a=arguments, args=[], i=0;
+		// if a[0] is a String, obj was omitted
+		args.push(typeof a[0] == "string" ? null : a[i++], a[i++]);
+		// if the arg-after-next is a String or Function, context was NOT omitted
+		var a1 = a[i+1];
+		args.push(typeof a1 == "string" || typeof a1 == "function" ? a[i++] : null, a[i++]);
+		// absorb any additional arguments
+		for(var l=a.length; i<l; i++){	args.push(a[i]); }
+		return connect_.apply(this, args);
+	},
+
+	disconnect:function(handle){
+		// summary:
+		//		Remove a link created by dojo.connect.
+		// description:
+		//		Removes the connection between event and the method referenced by handle.
+		// handle: Handle
+		//		the return value of the dojo.connect call that created the connection.
+
+		if(handle){
+			handle.remove();
+		}
+	},
+
+	subscribe:function(topic, context, method){
+		// summary:
+		//		Attach a listener to a named topic. The listener function is invoked whenever the
+		//		named topic is published (see: dojo.publish).
+		//		Returns a handle which is needed to unsubscribe this listener.
+		// topic: String
+		//		The topic to which to subscribe.
+		// context: Object?
+		//		Scope in which method will be invoked, or null for default scope.
+		// method: String|Function
+		//		The name of a function in context, or a function reference. This is the function that
+		//		is invoked when topic is published.
+		// example:
+		//	|	dojo.subscribe("alerts", null, function(caption, message){ alert(caption + "\n" + message); });
+		//	|	dojo.publish("alerts", [ "read this", "hello world" ]);
+		return hub.subscribe(topic, lang.hitch(context, method));
+	},
+
+	publish:function(topic, args){
+		// summary:
+		//		Invoke all listener method subscribed to topic.
+		// topic: String
+		//		The name of the topic to publish.
+		// args: Array?
+		//		An array of arguments. The arguments will be applied
+		//		to each topic subscriber (as first class parameters, via apply).
+		// example:
+		//	|	dojo.subscribe("alerts", null, function(caption, message){ alert(caption + "\n" + message); };
+		//	|	dojo.publish("alerts", [ "read this", "hello world" ]);
+		return hub.publish.apply(hub, [topic].concat(args));
+	},
+
+	connectPublisher:function(topic, obj, event){
+		// summary:
+		//		Ensure that every time obj.event() is called, a message is published
+		//		on the topic. Returns a handle which can be passed to
+		//		dojo.disconnect() to disable subsequent automatic publication on
+		//		the topic.
+		// topic: String
+		//		The name of the topic to publish.
+		// obj: Object?
+		//		The source object for the event function. Defaults to kernel.global
+		//		if null.
+		// event: String
+		//		The name of the event function in obj.
+		//		I.e. identifies a property obj[event].
+		// example:
+		//	|	dojo.connectPublisher("/ajax/start", dojo, "xhrGet");
+		var pf = function(){ connect.publish(topic, arguments); };
+		return event ? connect.connect(obj, event, pf) : connect.connect(obj, pf); //Handle
+	},
+
+	isCopyKey: function(e){
+		// summary:
+		//		Checks an event for the copy key (meta on Mac, and ctrl anywhere else)
+		// e: Event
+		//		Event object to examine
+		return e[evtCopyKey];	// Boolean
+	}
+};
+
+connect.unsubscribe = connect.disconnect;
+/*=====
+ connect.unsubscribe = function(handle){
+	 // summary:
+	 //		Remove a topic listener.
+	 // handle: Handle
+	 //		The handle returned from a call to subscribe.
+	 // example:
+	 //	|	var alerter = dojo.subscribe("alerts", null, function(caption, message){ alert(caption + "\n" + message); };
+	 //	|	...
+	 //	|	dojo.unsubscribe(alerter);
+ };
+ =====*/
+
+has("extend-dojo") && lang.mixin(dojo, connect);
+return connect;
+
+});
+
+

debian/missing-sources/dojo/_base/event.js

@@ -0,0 +1,59 @@
+define(["./kernel", "../on", "../has", "../dom-geometry"], function(dojo, on, has, dom){
+	// module:
+	//		dojo/_base/event
+
+	if(on._fixEvent){
+		var fixEvent = on._fixEvent;
+		on._fixEvent = function(evt, se){
+			// add some additional normalization for back-compat, this isn't in on.js because it is somewhat more expensive
+			evt = fixEvent(evt, se);
+			if(evt){
+				dom.normalizeEvent(evt);
+			}
+			return evt;
+		};		
+	}
+	
+	var ret = {
+		// summary:
+		//		This module defines dojo DOM event API.   Usually you should use dojo/on, and evt.stopPropagation() +
+		//		evt.preventDefault(), rather than this module.
+
+		fix: function(/*Event*/ evt, /*DOMNode*/ sender){
+			// summary:
+			//		normalizes properties on the event object including event
+			//		bubbling methods, keystroke normalization, and x/y positions
+			// evt: Event
+			//		native event object
+			// sender: DOMNode
+			//		node to treat as "currentTarget"
+			if(on._fixEvent){
+				return on._fixEvent(evt, sender);
+			}
+			return evt;	// Event
+		},
+	
+		stop: function(/*Event*/ evt){
+			// summary:
+			//		prevents propagation and clobbers the default action of the
+			//		passed event
+			// evt: Event
+			//		The event object. If omitted, window.event is used on IE.
+			if(has("dom-addeventlistener") || (evt && evt.preventDefault)){
+				evt.preventDefault();
+				evt.stopPropagation();
+			}else{
+				evt = evt || window.event;
+				evt.cancelBubble = true;
+				on._preventDefault.call(evt);
+			}
+		}
+	};
+
+	if(has("extend-dojo")){
+		dojo.fixEvent = ret.fix;
+		dojo.stopEvent = ret.stop;
+	}
+
+	return ret;
+});

debian/missing-sources/dojo/_base/kernel.js

@@ -0,0 +1,299 @@
+define(["../has", "./config", "require", "module"], function(has, config, require, module){
+	// module:
+	//		dojo/_base/kernel
+
+	// This module is the foundational module of the dojo boot sequence; it defines the dojo object.
+
+	var
+		// loop variables for this module
+		i, p,
+
+		// create dojo, dijit, and dojox
+		// FIXME: in 2.0 remove dijit, dojox being created by dojo
+		dijit = {},
+		dojox = {},
+		dojo = {
+			// summary:
+			//		This module is the foundational module of the dojo boot sequence; it defines the dojo object.
+
+			// notice dojo takes ownership of the value of the config module
+			config:config,
+			global:this,
+			dijit:dijit,
+			dojox:dojox
+		};
+
+
+	// Configure the scope map. For a 100% AMD application, the scope map is not needed other than to provide
+	// a _scopeName property for the dojo, dijit, and dojox root object so those packages can create
+	// unique names in the global space.
+	//
+	// Built, legacy modules use the scope map to allow those modules to be expressed as if dojo, dijit, and dojox,
+	// where global when in fact they are either global under different names or not global at all. In v1.6-, the
+	// config variable "scopeMap" was used to map names as used within a module to global names. This has been
+	// subsumed by the AMD map configuration variable which can relocate packages to different names. For backcompat,
+	// only the "*" mapping is supported. See http://livedocs.dojotoolkit.org/developer/design/loader#legacy-cross-domain-mode for details.
+	//
+	// The following computations contort the packageMap for this dojo instance into a scopeMap.
+	var scopeMap =
+			// a map from a name used in a legacy module to the (global variable name, object addressed by that name)
+			// always map dojo, dijit, and dojox
+			{
+				dojo:["dojo", dojo],
+				dijit:["dijit", dijit],
+				dojox:["dojox", dojox]
+			},
+
+		packageMap =
+			// the package map for this dojo instance; note, a foreign loader or no pacakgeMap results in the above default config
+			(require.map && require.map[module.id.match(/[^\/]+/)[0]]),
+
+		item;
+
+
+	// process all mapped top-level names for this instance of dojo
+	for(p in packageMap){
+		if(scopeMap[p]){
+			// mapped dojo, dijit, or dojox
+			scopeMap[p][0] = packageMap[p];
+		}else{
+			// some other top-level name
+			scopeMap[p] = [packageMap[p], {}];
+		}
+	}
+
+	// publish those names to _scopeName and, optionally, the global namespace
+	for(p in scopeMap){
+		item = scopeMap[p];
+		item[1]._scopeName = item[0];
+		if(!config.noGlobals){
+			this[item[0]] = item[1];
+		}
+	}
+	dojo.scopeMap = scopeMap;
+
+	/*===== dojo.__docParserConfigureScopeMap(scopeMap); =====*/
+
+	// FIXME: dojo.baseUrl and dojo.config.baseUrl should be deprecated
+	dojo.baseUrl = dojo.config.baseUrl = require.baseUrl;
+	dojo.isAsync = !has("dojo-loader") || require.async;
+	dojo.locale = config.locale;
+
+	var rev = "$Rev: 43d05c6 $".match(/\d+/);
+	dojo.version = {
+		// summary:
+		//		Version number of the Dojo Toolkit
+		// description:
+		//		Hash about the version, including
+		//
+		//		- major: Integer: Major version. If total version is "1.2.0beta1", will be 1
+		//		- minor: Integer: Minor version. If total version is "1.2.0beta1", will be 2
+		//		- patch: Integer: Patch version. If total version is "1.2.0beta1", will be 0
+		//		- flag: String: Descriptor flag. If total version is "1.2.0beta1", will be "beta1"
+		//		- revision: Number: The SVN rev from which dojo was pulled
+
+		major: 1, minor: 9, patch: 1, flag: "",
+		revision: rev ? +rev[0] : NaN,
+		toString: function(){
+			var v = dojo.version;
+			return v.major + "." + v.minor + "." + v.patch + v.flag + " (" + v.revision + ")";	// String
+		}
+	};
+
+	// If has("extend-dojo") is truthy, then as a dojo module is defined it should push it's definitions
+	// into the dojo object, and conversely. In 2.0, it will likely be unusual to augment another object
+	// as a result of defining a module. This has feature gives a way to force 2.0 behavior as the code
+	// is migrated. Absent specific advice otherwise, set extend-dojo to truthy.
+	has.add("extend-dojo", 1);
+
+
+	(Function("d", "d.eval = function(){return d.global.eval ? d.global.eval(arguments[0]) : eval(arguments[0]);}"))(dojo);
+	/*=====
+	dojo.eval = function(scriptText){
+		// summary:
+		//		A legacy method created for use exclusively by internal Dojo methods. Do not use this method
+		//		directly unless you understand its possibly-different implications on the platforms your are targeting.
+		// description:
+		//		Makes an attempt to evaluate scriptText in the global scope. The function works correctly for browsers
+		//		that support indirect eval.
+		//
+		//		As usual, IE does not. On IE, the only way to implement global eval is to
+		//		use execScript. Unfortunately, execScript does not return a value and breaks some current usages of dojo.eval.
+		//		This implementation uses the technique of executing eval in the scope of a function that is a single scope
+		//		frame below the global scope; thereby coming close to the global scope. Note carefully that
+		//
+		//		dojo.eval("var pi = 3.14;");
+		//
+		//		will define global pi in non-IE environments, but define pi only in a temporary local scope for IE. If you want
+		//		to define a global variable using dojo.eval, write something like
+		//
+		//		dojo.eval("window.pi = 3.14;")
+		// scriptText:
+		//		The text to evaluation.
+		// returns:
+		//		The result of the evaluation. Often `undefined`
+	};
+	=====*/
+
+
+	if(has("host-rhino")){
+		dojo.exit = function(exitcode){
+			quit(exitcode);
+		};
+	}else{
+		dojo.exit = function(){
+		};
+	}
+
+	has.add("dojo-guarantee-console",
+		// ensure that console.log, console.warn, etc. are defined
+		1
+	);
+	if(has("dojo-guarantee-console")){
+		typeof console != "undefined" || (console = {});
+		//	Be careful to leave 'log' always at the end
+		var cn = [
+			"assert", "count", "debug", "dir", "dirxml", "error", "group",
+			"groupEnd", "info", "profile", "profileEnd", "time", "timeEnd",
+			"trace", "warn", "log"
+		];
+		var tn;
+		i = 0;
+		while((tn = cn[i++])){
+			if(!console[tn]){
+				(function(){
+					var tcn = tn + "";
+					console[tcn] = ('log' in console) ? function(){
+						var a = Array.apply({}, arguments);
+						a.unshift(tcn + ":");
+						console["log"](a.join(" "));
+					} : function(){};
+					console[tcn]._fake = true;
+				})();
+			}
+		}
+	}
+
+	has.add("dojo-debug-messages",
+		// include dojo.deprecated/dojo.experimental implementations
+		!!config.isDebug
+	);
+	dojo.deprecated = dojo.experimental =  function(){};
+	if(has("dojo-debug-messages")){
+		dojo.deprecated = function(/*String*/ behaviour, /*String?*/ extra, /*String?*/ removal){
+			// summary:
+			//		Log a debug message to indicate that a behavior has been
+			//		deprecated.
+			// behaviour: String
+			//		The API or behavior being deprecated. Usually in the form
+			//		of "myApp.someFunction()".
+			// extra: String?
+			//		Text to append to the message. Often provides advice on a
+			//		new function or facility to achieve the same goal during
+			//		the deprecation period.
+			// removal: String?
+			//		Text to indicate when in the future the behavior will be
+			//		removed. Usually a version number.
+			// example:
+			//	| dojo.deprecated("myApp.getTemp()", "use myApp.getLocaleTemp() instead", "1.0");
+
+			var message = "DEPRECATED: " + behaviour;
+			if(extra){ message += " " + extra; }
+			if(removal){ message += " -- will be removed in version: " + removal; }
+			console.warn(message);
+		};
+
+		dojo.experimental = function(/* String */ moduleName, /* String? */ extra){
+			// summary:
+			//		Marks code as experimental.
+			// description:
+			//		This can be used to mark a function, file, or module as
+			//		experimental.	 Experimental code is not ready to be used, and the
+			//		APIs are subject to change without notice.	Experimental code may be
+			//		completed deleted without going through the normal deprecation
+			//		process.
+			// moduleName: String
+			//		The name of a module, or the name of a module file or a specific
+			//		function
+			// extra: String?
+			//		some additional message for the user
+			// example:
+			//	| dojo.experimental("dojo.data.Result");
+			// example:
+			//	| dojo.experimental("dojo.weather.toKelvin()", "PENDING approval from NOAA");
+
+			var message = "EXPERIMENTAL: " + moduleName + " -- APIs subject to change without notice.";
+			if(extra){ message += " " + extra; }
+			console.warn(message);
+		};
+	}
+
+	has.add("dojo-modulePaths",
+		// consume dojo.modulePaths processing
+		1
+	);
+	if(has("dojo-modulePaths")){
+		// notice that modulePaths won't be applied to any require's before the dojo/_base/kernel factory is run;
+		// this is the v1.6- behavior.
+		if(config.modulePaths){
+			dojo.deprecated("dojo.modulePaths", "use paths configuration");
+			var paths = {};
+			for(p in config.modulePaths){
+				paths[p.replace(/\./g, "/")] = config.modulePaths[p];
+			}
+			require({paths:paths});
+		}
+	}
+
+	has.add("dojo-moduleUrl",
+		// include dojo.moduleUrl
+		1
+	);
+	if(has("dojo-moduleUrl")){
+		dojo.moduleUrl = function(/*String*/module, /*String?*/url){
+			// summary:
+			//		Returns a URL relative to a module.
+			// example:
+			//	|	var pngPath = dojo.moduleUrl("acme","images/small.png");
+			//	|	console.dir(pngPath); // list the object properties
+			//	|	// create an image and set it's source to pngPath's value:
+			//	|	var img = document.createElement("img");
+			//	|	img.src = pngPath;
+			//	|	// add our image to the document
+			//	|	dojo.body().appendChild(img);
+			// example:
+			//		you may de-reference as far as you like down the package
+			//		hierarchy.  This is sometimes handy to avoid lenghty relative
+			//		urls or for building portable sub-packages. In this example,
+			//		the `acme.widget` and `acme.util` directories may be located
+			//		under different roots (see `dojo.registerModulePath`) but the
+			//		the modules which reference them can be unaware of their
+			//		relative locations on the filesystem:
+			//	|	// somewhere in a configuration block
+			//	|	dojo.registerModulePath("acme.widget", "../../acme/widget");
+			//	|	dojo.registerModulePath("acme.util", "../../util");
+			//	|
+			//	|	// ...
+			//	|
+			//	|	// code in a module using acme resources
+			//	|	var tmpltPath = dojo.moduleUrl("acme.widget","templates/template.html");
+			//	|	var dataPath = dojo.moduleUrl("acme.util","resources/data.json");
+
+			dojo.deprecated("dojo.moduleUrl()", "use require.toUrl", "2.0");
+
+			// require.toUrl requires a filetype; therefore, just append the suffix "/*.*" to guarantee a filetype, then
+			// remove the suffix from the result. This way clients can request a url w/out a filetype. This should be
+			// rare, but it maintains backcompat for the v1.x line (note: dojo.moduleUrl will be removed in v2.0).
+			// Notice * is an illegal filename so it won't conflict with any real path map that may exist the paths config.
+			var result = null;
+			if(module){
+				result = require.toUrl(module.replace(/\./g, "/") + (url ? ("/" + url) : "") + "/*.*").replace(/\/\*\.\*/, "") + (url ? "" : "/");
+			}
+			return result;
+		};
+	}
+
+	dojo._hasResource = {}; // for backward compatibility with layers built with 1.6 tooling
+
+	return dojo;
+});

debian/missing-sources/dojo/_base/lang.js

@@ -0,0 +1,605 @@
+define(["./kernel", "../has", "../sniff"], function(dojo, has){
+	// module:
+	//		dojo/_base/lang
+
+	has.add("bug-for-in-skips-shadowed", function(){
+		// if true, the for-in iterator skips object properties that exist in Object's prototype (IE 6 - ?)
+		for(var i in {toString: 1}){
+			return 0;
+		}
+		return 1;
+	});
+
+	// Helper methods
+	var _extraNames =
+			has("bug-for-in-skips-shadowed") ?
+				"hasOwnProperty.valueOf.isPrototypeOf.propertyIsEnumerable.toLocaleString.toString.constructor".split(".") : [],
+
+		_extraLen = _extraNames.length,
+
+		getProp = function(/*Array*/parts, /*Boolean*/create, /*Object*/context){
+			var p, i = 0, dojoGlobal = dojo.global;
+			if(!context){
+				if(!parts.length){
+					return dojoGlobal;
+				}else{
+					p = parts[i++];
+					try{
+						context = dojo.scopeMap[p] && dojo.scopeMap[p][1];
+					}catch(e){}
+					context = context || (p in dojoGlobal ? dojoGlobal[p] : (create ? dojoGlobal[p] = {} : undefined));
+				}
+			}
+			while(context && (p = parts[i++])){
+				context = (p in context ? context[p] : (create ? context[p] = {} : undefined));
+			}
+			return context; // mixed
+		},
+
+		opts = Object.prototype.toString,
+
+		efficient = function(obj, offset, startWith){
+			return (startWith||[]).concat(Array.prototype.slice.call(obj, offset||0));
+		},
+
+		_pattern = /\{([^\}]+)\}/g;
+
+	// Module export
+	var lang = {
+		// summary:
+		//		This module defines Javascript language extensions.
+
+		// _extraNames: String[]
+		//		Lists property names that must be explicitly processed during for-in iteration
+		//		in environments that have has("bug-for-in-skips-shadowed") true.
+		_extraNames:_extraNames,
+
+		_mixin: function(dest, source, copyFunc){
+			// summary:
+			//		Copies/adds all properties of source to dest; returns dest.
+			// dest: Object
+			//		The object to which to copy/add all properties contained in source.
+			// source: Object
+			//		The object from which to draw all properties to copy into dest.
+			// copyFunc: Function?
+			//		The process used to copy/add a property in source; defaults to the Javascript assignment operator.
+			// returns:
+			//		dest, as modified
+			// description:
+			//		All properties, including functions (sometimes termed "methods"), excluding any non-standard extensions
+			//		found in Object.prototype, are copied/added to dest. Copying/adding each particular property is
+			//		delegated to copyFunc (if any); copyFunc defaults to the Javascript assignment operator if not provided.
+			//		Notice that by default, _mixin executes a so-called "shallow copy" and aggregate types are copied/added by reference.
+			var name, s, i, empty = {};
+			for(name in source){
+				// the (!(name in empty) || empty[name] !== s) condition avoids copying properties in "source"
+				// inherited from Object.prototype.	 For example, if dest has a custom toString() method,
+				// don't overwrite it with the toString() method that source inherited from Object.prototype
+				s = source[name];
+				if(!(name in dest) || (dest[name] !== s && (!(name in empty) || empty[name] !== s))){
+					dest[name] = copyFunc ? copyFunc(s) : s;
+				}
+			}
+
+			if(has("bug-for-in-skips-shadowed")){
+				if(source){
+					for(i = 0; i < _extraLen; ++i){
+						name = _extraNames[i];
+						s = source[name];
+						if(!(name in dest) || (dest[name] !== s && (!(name in empty) || empty[name] !== s))){
+							dest[name] = copyFunc ? copyFunc(s) : s;
+						}
+					}
+				}
+			}
+
+			return dest; // Object
+		},
+
+		mixin: function(dest, sources){
+			// summary:
+			//		Copies/adds all properties of one or more sources to dest; returns dest.
+			// dest: Object
+			//		The object to which to copy/add all properties contained in source. If dest is falsy, then
+			//		a new object is manufactured before copying/adding properties begins.
+			// sources: Object...
+			//		One of more objects from which to draw all properties to copy into dest. sources are processed
+			//		left-to-right and if more than one of these objects contain the same property name, the right-most
+			//		value "wins".
+			// returns: Object
+			//		dest, as modified
+			// description:
+			//		All properties, including functions (sometimes termed "methods"), excluding any non-standard extensions
+			//		found in Object.prototype, are copied/added from sources to dest. sources are processed left to right.
+			//		The Javascript assignment operator is used to copy/add each property; therefore, by default, mixin
+			//		executes a so-called "shallow copy" and aggregate types are copied/added by reference.
+			// example:
+			//		make a shallow copy of an object
+			//	|	var copy = lang.mixin({}, source);
+			// example:
+			//		many class constructors often take an object which specifies
+			//		values to be configured on the object. In this case, it is
+			//		often simplest to call `lang.mixin` on the `this` object:
+			//	|	declare("acme.Base", null, {
+			//	|		constructor: function(properties){
+			//	|			// property configuration:
+			//	|			lang.mixin(this, properties);
+			//	|
+			//	|			console.log(this.quip);
+			//	|			//	...
+			//	|		},
+			//	|		quip: "I wasn't born yesterday, you know - I've seen movies.",
+			//	|		// ...
+			//	|	});
+			//	|
+			//	|	// create an instance of the class and configure it
+			//	|	var b = new acme.Base({quip: "That's what it does!" });
+			// example:
+			//		copy in properties from multiple objects
+			//	|	var flattened = lang.mixin(
+			//	|		{
+			//	|			name: "Frylock",
+			//	|			braces: true
+			//	|		},
+			//	|		{
+			//	|			name: "Carl Brutanananadilewski"
+			//	|		}
+			//	|	);
+			//	|
+			//	|	// will print "Carl Brutanananadilewski"
+			//	|	console.log(flattened.name);
+			//	|	// will print "true"
+			//	|	console.log(flattened.braces);
+
+			if(!dest){ dest = {}; }
+			for(var i = 1, l = arguments.length; i < l; i++){
+				lang._mixin(dest, arguments[i]);
+			}
+			return dest; // Object
+		},
+
+		setObject: function(name, value, context){
+			// summary:
+			//		Set a property from a dot-separated string, such as "A.B.C"
+			// description:
+			//		Useful for longer api chains where you have to test each object in
+			//		the chain, or when you have an object reference in string format.
+			//		Objects are created as needed along `path`. Returns the passed
+			//		value if setting is successful or `undefined` if not.
+			// name: String
+			//		Path to a property, in the form "A.B.C".
+			// value: anything
+			//		value or object to place at location given by name
+			// context: Object?
+			//		Optional. Object to use as root of path. Defaults to
+			//		`dojo.global`.
+			// example:
+			//		set the value of `foo.bar.baz`, regardless of whether
+			//		intermediate objects already exist:
+			//	| lang.setObject("foo.bar.baz", value);
+			// example:
+			//		without `lang.setObject`, we often see code like this:
+			//	| // ensure that intermediate objects are available
+			//	| if(!obj["parent"]){ obj.parent = {}; }
+			//	| if(!obj.parent["child"]){ obj.parent.child = {}; }
+			//	| // now we can safely set the property
+			//	| obj.parent.child.prop = "some value";
+			//		whereas with `lang.setObject`, we can shorten that to:
+			//	| lang.setObject("parent.child.prop", "some value", obj);
+
+			var parts = name.split("."), p = parts.pop(), obj = getProp(parts, true, context);
+			return obj && p ? (obj[p] = value) : undefined; // Object
+		},
+
+		getObject: function(name, create, context){
+			// summary:
+			//		Get a property from a dot-separated string, such as "A.B.C"
+			// description:
+			//		Useful for longer api chains where you have to test each object in
+			//		the chain, or when you have an object reference in string format.
+			// name: String
+			//		Path to an property, in the form "A.B.C".
+			// create: Boolean?
+			//		Optional. Defaults to `false`. If `true`, Objects will be
+			//		created at any point along the 'path' that is undefined.
+			// context: Object?
+			//		Optional. Object to use as root of path. Defaults to
+			//		'dojo.global'. Null may be passed.
+			return getProp(name.split("."), create, context); // Object
+		},
+
+		exists: function(name, obj){
+			// summary:
+			//		determine if an object supports a given method
+			// description:
+			//		useful for longer api chains where you have to test each object in
+			//		the chain. Useful for object and method detection.
+			// name: String
+			//		Path to an object, in the form "A.B.C".
+			// obj: Object?
+			//		Object to use as root of path. Defaults to
+			//		'dojo.global'. Null may be passed.
+			// example:
+			//	| // define an object
+			//	| var foo = {
+			//	|		bar: { }
+			//	| };
+			//	|
+			//	| // search the global scope
+			//	| lang.exists("foo.bar"); // true
+			//	| lang.exists("foo.bar.baz"); // false
+			//	|
+			//	| // search from a particular scope
+			//	| lang.exists("bar", foo); // true
+			//	| lang.exists("bar.baz", foo); // false
+			return lang.getObject(name, false, obj) !== undefined; // Boolean
+		},
+
+		// Crockford (ish) functions
+
+		isString: function(it){
+			// summary:
+			//		Return true if it is a String
+			// it: anything
+			//		Item to test.
+			return (typeof it == "string" || it instanceof String); // Boolean
+		},
+
+		isArray: function(it){
+			// summary:
+			//		Return true if it is an Array.
+			//		Does not work on Arrays created in other windows.
+			// it: anything
+			//		Item to test.
+			return it && (it instanceof Array || typeof it == "array"); // Boolean
+		},
+
+		isFunction: function(it){
+			// summary:
+			//		Return true if it is a Function
+			// it: anything
+			//		Item to test.
+			return opts.call(it) === "[object Function]";
+		},
+
+		isObject: function(it){
+			// summary:
+			//		Returns true if it is a JavaScript object (or an Array, a Function
+			//		or null)
+			// it: anything
+			//		Item to test.
+			return it !== undefined &&
+				(it === null || typeof it == "object" || lang.isArray(it) || lang.isFunction(it)); // Boolean
+		},
+
+		isArrayLike: function(it){
+			// summary:
+			//		similar to isArray() but more permissive
+			// it: anything
+			//		Item to test.
+			// returns:
+			//		If it walks like a duck and quacks like a duck, return `true`
+			// description:
+			//		Doesn't strongly test for "arrayness".  Instead, settles for "isn't
+			//		a string or number and has a length property". Arguments objects
+			//		and DOM collections will return true when passed to
+			//		isArrayLike(), but will return false when passed to
+			//		isArray().
+			return it && it !== undefined && // Boolean
+				// keep out built-in constructors (Number, String, ...) which have length
+				// properties
+				!lang.isString(it) && !lang.isFunction(it) &&
+				!(it.tagName && it.tagName.toLowerCase() == 'form') &&
+				(lang.isArray(it) || isFinite(it.length));
+		},
+
+		isAlien: function(it){
+			// summary:
+			//		Returns true if it is a built-in function or some other kind of
+			//		oddball that *should* report as a function but doesn't
+			return it && !lang.isFunction(it) && /\{\s*\[native code\]\s*\}/.test(String(it)); // Boolean
+		},
+
+		extend: function(ctor, props){
+			// summary:
+			//		Adds all properties and methods of props to constructor's
+			//		prototype, making them available to all instances created with
+			//		constructor.
+			// ctor: Object
+			//		Target constructor to extend.
+			// props: Object
+			//		One or more objects to mix into ctor.prototype
+			for(var i=1, l=arguments.length; i<l; i++){
+				lang._mixin(ctor.prototype, arguments[i]);
+			}
+			return ctor; // Object
+		},
+
+		_hitchArgs: function(scope, method){
+			var pre = lang._toArray(arguments, 2);
+			var named = lang.isString(method);
+			return function(){
+				// arrayify arguments
+				var args = lang._toArray(arguments);
+				// locate our method
+				var f = named ? (scope||dojo.global)[method] : method;
+				// invoke with collected args
+				return f && f.apply(scope || this, pre.concat(args)); // mixed
+			}; // Function
+		},
+
+		hitch: function(scope, method){
+			// summary:
+			//		Returns a function that will only ever execute in the a given scope.
+			//		This allows for easy use of object member functions
+			//		in callbacks and other places in which the "this" keyword may
+			//		otherwise not reference the expected scope.
+			//		Any number of default positional arguments may be passed as parameters
+			//		beyond "method".
+			//		Each of these values will be used to "placehold" (similar to curry)
+			//		for the hitched function.
+			// scope: Object
+			//		The scope to use when method executes. If method is a string,
+			//		scope is also the object containing method.
+			// method: Function|String...
+			//		A function to be hitched to scope, or the name of the method in
+			//		scope to be hitched.
+			// example:
+			//	|	lang.hitch(foo, "bar")();
+			//		runs foo.bar() in the scope of foo
+			// example:
+			//	|	lang.hitch(foo, myFunction);
+			//		returns a function that runs myFunction in the scope of foo
+			// example:
+			//		Expansion on the default positional arguments passed along from
+			//		hitch. Passed args are mixed first, additional args after.
+			//	|	var foo = { bar: function(a, b, c){ console.log(a, b, c); } };
+			//	|	var fn = lang.hitch(foo, "bar", 1, 2);
+			//	|	fn(3); // logs "1, 2, 3"
+			// example:
+			//	|	var foo = { bar: 2 };
+			//	|	lang.hitch(foo, function(){ this.bar = 10; })();
+			//		execute an anonymous function in scope of foo
+			if(arguments.length > 2){
+				return lang._hitchArgs.apply(dojo, arguments); // Function
+			}
+			if(!method){
+				method = scope;
+				scope = null;
+			}
+			if(lang.isString(method)){
+				scope = scope || dojo.global;
+				if(!scope[method]){ throw(['lang.hitch: scope["', method, '"] is null (scope="', scope, '")'].join('')); }
+				return function(){ return scope[method].apply(scope, arguments || []); }; // Function
+			}
+			return !scope ? method : function(){ return method.apply(scope, arguments || []); }; // Function
+		},
+
+		delegate: (function(){
+			// boodman/crockford delegation w/ cornford optimization
+			function TMP(){}
+			return function(obj, props){
+				TMP.prototype = obj;
+				var tmp = new TMP();
+				TMP.prototype = null;
+				if(props){
+					lang._mixin(tmp, props);
+				}
+				return tmp; // Object
+			};
+		})(),
+		/*=====
+		delegate: function(obj, props){
+			// summary:
+			//		Returns a new object which "looks" to obj for properties which it
+			//		does not have a value for. Optionally takes a bag of properties to
+			//		seed the returned object with initially.
+			// description:
+			//		This is a small implementation of the Boodman/Crockford delegation
+			//		pattern in JavaScript. An intermediate object constructor mediates
+			//		the prototype chain for the returned object, using it to delegate
+			//		down to obj for property lookup when object-local lookup fails.
+			//		This can be thought of similarly to ES4's "wrap", save that it does
+			//		not act on types but rather on pure objects.
+			// obj: Object
+			//		The object to delegate to for properties not found directly on the
+			//		return object or in props.
+			// props: Object...
+			//		an object containing properties to assign to the returned object
+			// returns:
+			//		an Object of anonymous type
+			// example:
+			//	|	var foo = { bar: "baz" };
+			//	|	var thinger = lang.delegate(foo, { thud: "xyzzy"});
+			//	|	thinger.bar == "baz"; // delegated to foo
+			//	|	foo.thud == undefined; // by definition
+			//	|	thinger.thud == "xyzzy"; // mixed in from props
+			//	|	foo.bar = "thonk";
+			//	|	thinger.bar == "thonk"; // still delegated to foo's bar
+		},
+		=====*/
+
+		_toArray: has("ie") ?
+			(function(){
+				function slow(obj, offset, startWith){
+					var arr = startWith||[];
+					for(var x = offset || 0; x < obj.length; x++){
+						arr.push(obj[x]);
+					}
+					return arr;
+				}
+				return function(obj){
+					return ((obj.item) ? slow : efficient).apply(this, arguments);
+				};
+			})() : efficient,
+		/*=====
+		 _toArray: function(obj, offset, startWith){
+			 // summary:
+			 //		Converts an array-like object (i.e. arguments, DOMCollection) to an
+			 //		array. Returns a new Array with the elements of obj.
+			 // obj: Object
+			 //		the object to "arrayify". We expect the object to have, at a
+			 //		minimum, a length property which corresponds to integer-indexed
+			 //		properties.
+			 // offset: Number?
+			 //		the location in obj to start iterating from. Defaults to 0.
+			 //		Optional.
+			 // startWith: Array?
+			 //		An array to pack with the properties of obj. If provided,
+			 //		properties in obj are appended at the end of startWith and
+			 //		startWith is the returned array.
+		 },
+		 =====*/
+
+		partial: function(/*Function|String*/ method /*, ...*/){
+			// summary:
+			//		similar to hitch() except that the scope object is left to be
+			//		whatever the execution context eventually becomes.
+			// description:
+			//		Calling lang.partial is the functional equivalent of calling:
+			//		|	lang.hitch(null, funcName, ...);
+			// method:
+			//		The function to "wrap"
+			var arr = [ null ];
+			return lang.hitch.apply(dojo, arr.concat(lang._toArray(arguments))); // Function
+		},
+
+		clone: function(/*anything*/ src){
+			// summary:
+			//		Clones objects (including DOM nodes) and all children.
+			//		Warning: do not clone cyclic structures.
+			// src:
+			//		The object to clone
+			if(!src || typeof src != "object" || lang.isFunction(src)){
+				// null, undefined, any non-object, or function
+				return src;	// anything
+			}
+			if(src.nodeType && "cloneNode" in src){
+				// DOM Node
+				return src.cloneNode(true); // Node
+			}
+			if(src instanceof Date){
+				// Date
+				return new Date(src.getTime());	// Date
+			}
+			if(src instanceof RegExp){
+				// RegExp
+				return new RegExp(src);   // RegExp
+			}
+			var r, i, l;
+			if(lang.isArray(src)){
+				// array
+				r = [];
+				for(i = 0, l = src.length; i < l; ++i){
+					if(i in src){
+						r.push(lang.clone(src[i]));
+					}
+				}
+				// we don't clone functions for performance reasons
+				//		}else if(d.isFunction(src)){
+				//			// function
+				//			r = function(){ return src.apply(this, arguments); };
+			}else{
+				// generic objects
+				r = src.constructor ? new src.constructor() : {};
+			}
+			return lang._mixin(r, src, lang.clone);
+		},
+
+
+		trim: String.prototype.trim ?
+			function(str){ return str.trim(); } :
+			function(str){ return str.replace(/^\s\s*/, '').replace(/\s\s*$/, ''); },
+		/*=====
+		 trim: function(str){
+			 // summary:
+			 //		Trims whitespace from both sides of the string
+			 // str: String
+			 //		String to be trimmed
+			 // returns: String
+			 //		Returns the trimmed string
+			 // description:
+			 //		This version of trim() was selected for inclusion into the base due
+			 //		to its compact size and relatively good performance
+			 //		(see [Steven Levithan's blog](http://blog.stevenlevithan.com/archives/faster-trim-javascript)
+			 //		Uses String.prototype.trim instead, if available.
+			 //		The fastest but longest version of this function is located at
+			 //		lang.string.trim()
+		 },
+		 =====*/
+
+		replace: function(tmpl, map, pattern){
+			// summary:
+			//		Performs parameterized substitutions on a string. Throws an
+			//		exception if any parameter is unmatched.
+			// tmpl: String
+			//		String to be used as a template.
+			// map: Object|Function
+			//		If an object, it is used as a dictionary to look up substitutions.
+			//		If a function, it is called for every substitution with following parameters:
+			//		a whole match, a name, an offset, and the whole template
+			//		string (see https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Global_Objects/String/replace
+			//		for more details).
+			// pattern: RegEx?
+			//		Optional regular expression objects that overrides the default pattern.
+			//		Must be global and match one item. The default is: /\{([^\}]+)\}/g,
+			//		which matches patterns like that: "{xxx}", where "xxx" is any sequence
+			//		of characters, which doesn't include "}".
+			// returns: String
+			//		Returns the substituted string.
+			// example:
+			//	|	// uses a dictionary for substitutions:
+			//	|	lang.replace("Hello, {name.first} {name.last} AKA {nick}!",
+			//	|		{
+			//	|			nick: "Bob",
+			//	|			name: {
+			//	|				first:	"Robert",
+			//	|				middle: "X",
+			//	|				last:		"Cringely"
+			//	|			}
+			//	|		});
+			//	|	// returns: Hello, Robert Cringely AKA Bob!
+			// example:
+			//	|	// uses an array for substitutions:
+			//	|	lang.replace("Hello, {0} {2}!",
+			//	|		["Robert", "X", "Cringely"]);
+			//	|	// returns: Hello, Robert Cringely!
+			// example:
+			//	|	// uses a function for substitutions:
+			//	|	function sum(a){
+			//	|		var t = 0;
+			//	|		arrayforEach(a, function(x){ t += x; });
+			//	|		return t;
+			//	|	}
+			//	|	lang.replace(
+			//	|		"{count} payments averaging {avg} USD per payment.",
+			//	|		lang.hitch(
+			//	|			{ payments: [11, 16, 12] },
+			//	|			function(_, key){
+			//	|				switch(key){
+			//	|					case "count": return this.payments.length;
+			//	|					case "min":		return Math.min.apply(Math, this.payments);
+			//	|					case "max":		return Math.max.apply(Math, this.payments);
+			//	|					case "sum":		return sum(this.payments);
+			//	|					case "avg":		return sum(this.payments) / this.payments.length;
+			//	|				}
+			//	|			}
+			//	|		)
+			//	|	);
+			//	|	// prints: 3 payments averaging 13 USD per payment.
+			// example:
+			//	|	// uses an alternative PHP-like pattern for substitutions:
+			//	|	lang.replace("Hello, ${0} ${2}!",
+			//	|		["Robert", "X", "Cringely"], /\$\{([^\}]+)\}/g);
+			//	|	// returns: Hello, Robert Cringely!
+
+			return tmpl.replace(pattern || _pattern, lang.isFunction(map) ?
+				map : function(_, k){ return lang.getObject(k, false, map); });
+		}
+	};
+
+	has("extend-dojo") && lang.mixin(dojo, lang);
+
+	return lang;
+});
+

debian/missing-sources/dojo/_base/sniff.js

@@ -0,0 +1,93 @@
+define(["./kernel", "./lang", "../sniff"], function(dojo, lang, has){
+	// module:
+	//		dojo/_base/sniff
+
+	/*=====
+	return {
+		// summary:
+		//		Deprecated.   New code should use dojo/sniff.
+		//		This module populates the dojo browser version sniffing properties like dojo.isIE.
+	};
+	=====*/
+
+	if(!has("host-browser")){
+		return has;
+	}
+
+	// no idea what this is for, or if it's used
+	dojo._name = "browser";
+
+	lang.mixin(dojo, {
+		// isBrowser: Boolean
+		//		True if the client is a web-browser
+		isBrowser: true,
+
+		// isFF: Number|undefined
+		//		Version as a Number if client is FireFox. undefined otherwise. Corresponds to
+		//		major detected FireFox version (1.5, 2, 3, etc.)
+		isFF: has("ff"),
+
+		// isIE: Number|undefined
+		//		Version as a Number if client is MSIE(PC). undefined otherwise. Corresponds to
+		//		major detected IE version (6, 7, 8, etc.)
+		isIE: has("ie"),
+
+		// isKhtml: Number|undefined
+		//		Version as a Number if client is a KHTML browser. undefined otherwise. Corresponds to major
+		//		detected version.
+		isKhtml: has("khtml"),
+
+		// isWebKit: Number|undefined
+		//		Version as a Number if client is a WebKit-derived browser (Konqueror,
+		//		Safari, Chrome, etc.). undefined otherwise.
+		isWebKit: has("webkit"),
+
+		// isMozilla: Number|undefined
+		//		Version as a Number if client is a Mozilla-based browser (Firefox,
+		//		SeaMonkey). undefined otherwise. Corresponds to major detected version.
+		isMozilla: has("mozilla"),
+		// isMoz: Number|undefined
+		//		Version as a Number if client is a Mozilla-based browser (Firefox,
+		//		SeaMonkey). undefined otherwise. Corresponds to major detected version.
+		isMoz: has("mozilla"),
+
+		// isOpera: Number|undefined
+		//		Version as a Number if client is Opera. undefined otherwise. Corresponds to
+		//		major detected version.
+		isOpera: has("opera"),
+
+		// isSafari: Number|undefined
+		//		Version as a Number if client is Safari or iPhone. undefined otherwise.
+		isSafari: has("safari"),
+
+		// isChrome: Number|undefined
+		//		Version as a Number if client is Chrome browser. undefined otherwise.
+		isChrome: has("chrome"),
+
+		// isMac: Boolean
+		//		True if the client runs on Mac
+		isMac: has("mac"),
+
+		// isIos: Number|undefined
+		//		Version as a Number if client is iPhone, iPod, or iPad. undefined otherwise.
+		isIos: has("ios"),
+
+		// isAndroid: Number|undefined
+		//		Version as a Number if client is android browser. undefined otherwise.
+		isAndroid: has("android"),
+
+		// isWii: Boolean
+		//		True if client is Wii
+		isWii: has("wii"),
+
+		// isQuirks: Boolean
+		//		Page is in quirks mode.
+		isQuirks: has("quirks"),
+
+		// isAir: Boolean
+		//		True if client is Adobe Air
+		isAir: has("air")
+	});
+
+	return has;
+});

debian/missing-sources/dojo/_base/window.js

@@ -0,0 +1,134 @@
+define(["./kernel", "./lang", "../sniff"], function(dojo, lang, has){
+// module:
+//		dojo/_base/window
+
+var ret = {
+	// summary:
+	//		API to save/set/restore the global/document scope.
+
+	global: dojo.global,
+	/*=====
+	 global: {
+		 // summary:
+		 //		Alias for the current window. 'global' can be modified
+		 //		for temporary context shifting. See also withGlobal().
+		 // description:
+		 //		Use this rather than referring to 'window' to ensure your code runs
+		 //		correctly in managed contexts.
+	 },
+	 =====*/
+
+	doc: this["document"] || null,
+	/*=====
+	doc: {
+		// summary:
+		//		Alias for the current document. 'doc' can be modified
+		//		for temporary context shifting. See also withDoc().
+		// description:
+		//		Use this rather than referring to 'window.document' to ensure your code runs
+		//		correctly in managed contexts.
+		// example:
+		//	|	n.appendChild(dojo.doc.createElement('div'));
+	},
+	=====*/
+
+	body: function(/*Document?*/ doc){
+		// summary:
+		//		Return the body element of the specified document or of dojo/_base/window::doc.
+		// example:
+		//	|	win.body().appendChild(dojo.doc.createElement('div'));
+
+		// Note: document.body is not defined for a strict xhtml document
+		// Would like to memoize this, but dojo.doc can change vi dojo.withDoc().
+		doc = doc || dojo.doc;
+		return doc.body || doc.getElementsByTagName("body")[0]; // Node
+	},
+
+	setContext: function(/*Object*/ globalObject, /*DocumentElement*/ globalDocument){
+		// summary:
+		//		changes the behavior of many core Dojo functions that deal with
+		//		namespace and DOM lookup, changing them to work in a new global
+		//		context (e.g., an iframe). The varibles dojo.global and dojo.doc
+		//		are modified as a result of calling this function and the result of
+		//		`dojo.body()` likewise differs.
+		dojo.global = ret.global = globalObject;
+		dojo.doc = ret.doc = globalDocument;
+	},
+
+	withGlobal: function(	/*Object*/ globalObject,
+							/*Function*/ callback,
+							/*Object?*/ thisObject,
+							/*Array?*/ cbArguments){
+		// summary:
+		//		Invoke callback with globalObject as dojo.global and
+		//		globalObject.document as dojo.doc.
+		// description:
+		//		Invoke callback with globalObject as dojo.global and
+		//		globalObject.document as dojo.doc. If provided, globalObject
+		//		will be executed in the context of object thisObject
+		//		When callback() returns or throws an error, the dojo.global
+		//		and dojo.doc will be restored to its previous state.
+
+		var oldGlob = dojo.global;
+		try{
+			dojo.global = ret.global = globalObject;
+			return ret.withDoc.call(null, globalObject.document, callback, thisObject, cbArguments);
+		}finally{
+			dojo.global = ret.global = oldGlob;
+		}
+	},
+
+	withDoc: function(	/*DocumentElement*/ documentObject,
+						/*Function*/ callback,
+						/*Object?*/ thisObject,
+						/*Array?*/ cbArguments){
+		// summary:
+		//		Invoke callback with documentObject as dojo/_base/window::doc.
+		// description:
+		//		Invoke callback with documentObject as dojo/_base/window::doc. If provided,
+		//		callback will be executed in the context of object thisObject
+		//		When callback() returns or throws an error, the dojo/_base/window::doc will
+		//		be restored to its previous state.
+
+		var oldDoc = ret.doc,
+			oldQ = has("quirks"),
+			oldIE = has("ie"), isIE, mode, pwin;
+
+		try{
+			dojo.doc = ret.doc = documentObject;
+			// update dojo.isQuirks and the value of the has feature "quirks".
+			// remove setting dojo.isQuirks and dojo.isIE for 2.0
+			dojo.isQuirks = has.add("quirks", dojo.doc.compatMode == "BackCompat", true, true); // no need to check for QuirksMode which was Opera 7 only
+
+			if(has("ie")){
+				if((pwin = documentObject.parentWindow) && pwin.navigator){
+					// re-run IE detection logic and update dojo.isIE / has("ie")
+					// (the only time parentWindow/navigator wouldn't exist is if we were not
+					// passed an actual legitimate document object)
+					isIE = parseFloat(pwin.navigator.appVersion.split("MSIE ")[1]) || undefined;
+					mode = documentObject.documentMode;
+					if(mode && mode != 5 && Math.floor(isIE) != mode){
+						isIE = mode;
+					}
+					dojo.isIE = has.add("ie", isIE, true, true);
+				}
+			}
+
+			if(thisObject && typeof callback == "string"){
+				callback = thisObject[callback];
+			}
+
+			return callback.apply(thisObject, cbArguments || []);
+		}finally{
+			dojo.doc = ret.doc = oldDoc;
+			dojo.isQuirks = has.add("quirks", oldQ, true, true);
+			dojo.isIE = has.add("ie", oldIE, true, true);
+		}
+	}
+};
+
+has("extend-dojo") && lang.mixin(dojo, ret);
+
+return ret;
+
+});

debian/missing-sources/dojo/aspect.js

@@ -0,0 +1,223 @@
+define([], function(){
+
+	// module:
+	//		dojo/aspect
+
+	"use strict";
+	var undefined, nextId = 0;
+	function advise(dispatcher, type, advice, receiveArguments){
+		var previous = dispatcher[type];
+		var around = type == "around";
+		var signal;
+		if(around){
+			var advised = advice(function(){
+				return previous.advice(this, arguments);
+			});
+			signal = {
+				remove: function(){
+					if(advised){
+						advised = dispatcher = advice = null;
+					}
+				},
+				advice: function(target, args){
+					return advised ?
+						advised.apply(target, args) :  // called the advised function
+						previous.advice(target, args); // cancelled, skip to next one
+				}
+			};
+		}else{
+			// create the remove handler
+			signal = {
+				remove: function(){
+					if(signal.advice){
+						var previous = signal.previous;
+						var next = signal.next;
+						if(!next && !previous){
+							delete dispatcher[type];
+						}else{
+							if(previous){
+								previous.next = next;
+							}else{
+								dispatcher[type] = next;
+							}
+							if(next){
+								next.previous = previous;
+							}
+						}
+
+						// remove the advice to signal that this signal has been removed
+						dispatcher = advice = signal.advice = null;
+					}
+				},
+				id: nextId++,
+				advice: advice,
+				receiveArguments: receiveArguments
+			};
+		}
+		if(previous && !around){
+			if(type == "after"){
+				// add the listener to the end of the list
+				// note that we had to change this loop a little bit to workaround a bizarre IE10 JIT bug
+				while(previous.next && (previous = previous.next)){}
+				previous.next = signal;
+				signal.previous = previous;
+			}else if(type == "before"){
+				// add to beginning
+				dispatcher[type] = signal;
+				signal.next = previous;
+				previous.previous = signal;
+			}
+		}else{
+			// around or first one just replaces
+			dispatcher[type] = signal;
+		}
+		return signal;
+	}
+	function aspect(type){
+		return function(target, methodName, advice, receiveArguments){
+			var existing = target[methodName], dispatcher;
+			if(!existing || existing.target != target){
+				// no dispatcher in place
+				target[methodName] = dispatcher = function(){
+					var executionId = nextId;
+					// before advice
+					var args = arguments;
+					var before = dispatcher.before;
+					while(before){
+						args = before.advice.apply(this, args) || args;
+						before = before.next;
+					}
+					// around advice
+					if(dispatcher.around){
+						var results = dispatcher.around.advice(this, args);
+					}
+					// after advice
+					var after = dispatcher.after;
+					while(after && after.id < executionId){
+						if(after.receiveArguments){
+							var newResults = after.advice.apply(this, args);
+							// change the return value only if a new value was returned
+							results = newResults === undefined ? results : newResults;
+						}else{
+							results = after.advice.call(this, results, args);
+						}
+						after = after.next;
+					}
+					return results;
+				};
+				if(existing){
+					dispatcher.around = {advice: function(target, args){
+						return existing.apply(target, args);
+					}};
+				}
+				dispatcher.target = target;
+			}
+			var results = advise((dispatcher || existing), type, advice, receiveArguments);
+			advice = null;
+			return results;
+		};
+	}
+
+	// TODOC: after/before/around return object
+
+	var after = aspect("after");
+	/*=====
+	after = function(target, methodName, advice, receiveArguments){
+		// summary:
+		//		The "after" export of the aspect module is a function that can be used to attach
+		//		"after" advice to a method. This function will be executed after the original method
+		//		is executed. By default the function will be called with a single argument, the return
+		//		value of the original method, or the the return value of the last executed advice (if a previous one exists).
+		//		The fourth (optional) argument can be set to true to so the function receives the original
+		//		arguments (from when the original method was called) rather than the return value.
+		//		If there are multiple "after" advisors, they are executed in the order they were registered.
+		// target: Object
+		//		This is the target object
+		// methodName: String
+		//		This is the name of the method to attach to.
+		// advice: Function
+		//		This is function to be called after the original method
+		// receiveArguments: Boolean?
+		//		If this is set to true, the advice function receives the original arguments (from when the original mehtod
+		//		was called) rather than the return value of the original/previous method.
+		// returns:
+		//		A signal object that can be used to cancel the advice. If remove() is called on this signal object, it will
+		//		stop the advice function from being executed.
+	};
+	=====*/
+
+	var before = aspect("before");
+	/*=====
+	before = function(target, methodName, advice){
+		// summary:
+		//		The "before" export of the aspect module is a function that can be used to attach
+		//		"before" advice to a method. This function will be executed before the original method
+		//		is executed. This function will be called with the arguments used to call the method.
+		//		This function may optionally return an array as the new arguments to use to call
+		//		the original method (or the previous, next-to-execute before advice, if one exists).
+		//		If the before method doesn't return anything (returns undefined) the original arguments
+		//		will be preserved.
+		//		If there are multiple "before" advisors, they are executed in the reverse order they were registered.
+		// target: Object
+		//		This is the target object
+		// methodName: String
+		//		This is the name of the method to attach to.
+		// advice: Function
+		//		This is function to be called before the original method
+	};
+	=====*/
+
+	var around = aspect("around");
+	/*=====
+	 around = function(target, methodName, advice){
+		// summary:
+		//		The "around" export of the aspect module is a function that can be used to attach
+		//		"around" advice to a method. The advisor function is immediately executed when
+		//		the around() is called, is passed a single argument that is a function that can be
+		//		called to continue execution of the original method (or the next around advisor).
+		//		The advisor function should return a function, and this function will be called whenever
+		//		the method is called. It will be called with the arguments used to call the method.
+		//		Whatever this function returns will be returned as the result of the method call (unless after advise changes it).
+		// example:
+		//		If there are multiple "around" advisors, the most recent one is executed first,
+		//		which can then delegate to the next one and so on. For example:
+		//		|	around(obj, "foo", function(originalFoo){
+		//		|		return function(){
+		//		|			var start = new Date().getTime();
+		//		|			var results = originalFoo.apply(this, arguments); // call the original
+		//		|			var end = new Date().getTime();
+		//		|			console.log("foo execution took " + (end - start) + " ms");
+		//		|			return results;
+		//		|		};
+		//		|	});
+		// target: Object
+		//		This is the target object
+		// methodName: String
+		//		This is the name of the method to attach to.
+		// advice: Function
+		//		This is function to be called around the original method
+	};
+	=====*/
+
+	return {
+		// summary:
+		//		provides aspect oriented programming functionality, allowing for
+		//		one to add before, around, or after advice on existing methods.
+		// example:
+		//	|	define(["dojo/aspect"], function(aspect){
+		//	|		var signal = aspect.after(targetObject, "methodName", function(someArgument){
+		//	|			this will be called when targetObject.methodName() is called, after the original function is called
+		//	|		});
+		//
+		// example:
+		//	The returned signal object can be used to cancel the advice.
+		//	|	signal.remove(); // this will stop the advice from being executed anymore
+		//	|	aspect.before(targetObject, "methodName", function(someArgument){
+		//	|		// this will be called when targetObject.methodName() is called, before the original function is called
+		//	|	 });
+
+		before: before,
+		around: around,
+		after: after
+	};
+});

debian/missing-sources/dojo/dom-attr.js

@@ -0,0 +1,220 @@
+define(["exports", "./sniff", "./_base/lang", "./dom", "./dom-style", "./dom-prop"],
+		function(exports, has, lang, dom, style, prop){
+	// module:
+	//		dojo/dom-attr
+	// summary:
+	//		This module defines the core dojo DOM attributes API.
+
+	// TODOC: summary not showing up in output see https://github.com/csnover/js-doc-parse/issues/42
+
+	// =============================
+	// Element attribute Functions
+	// =============================
+
+	// This module will be obsolete soon. Use dojo/prop instead.
+
+	// dojo.attr() should conform to http://www.w3.org/TR/DOM-Level-2-Core/
+
+	// attribute-related functions (to be obsolete soon)
+
+	var forcePropNames = {
+			innerHTML:	1,
+			className:	1,
+			htmlFor:	has("ie"),
+			value:		1
+		},
+		attrNames = {
+			// original attribute names
+			classname: "class",
+			htmlfor: "for",
+			// for IE
+			tabindex: "tabIndex",
+			readonly: "readOnly"
+		};
+
+	function _hasAttr(node, name){
+		var attr = node.getAttributeNode && node.getAttributeNode(name);
+		return attr && attr.specified; // Boolean
+	}
+
+	// There is a difference in the presence of certain properties and their default values
+	// between browsers. For example, on IE "disabled" is present on all elements,
+	// but it is value is "false"; "tabIndex" of <div> returns 0 by default on IE, yet other browsers
+	// can return -1.
+
+	exports.has = function hasAttr(/*DOMNode|String*/ node, /*String*/ name){
+		// summary:
+		//		Returns true if the requested attribute is specified on the
+		//		given element, and false otherwise.
+		// node: DOMNode|String
+		//		id or reference to the element to check
+		// name: String
+		//		the name of the attribute
+		// returns: Boolean
+		//		true if the requested attribute is specified on the
+		//		given element, and false otherwise
+
+		var lc = name.toLowerCase();
+		return forcePropNames[prop.names[lc] || name] || _hasAttr(dom.byId(node), attrNames[lc] || name);	// Boolean
+	};
+
+	exports.get = function getAttr(/*DOMNode|String*/ node, /*String*/ name){
+		// summary:
+		//		Gets an attribute on an HTML element.
+		// description:
+		//		Handles normalized getting of attributes on DOM Nodes.
+		// node: DOMNode|String
+		//		id or reference to the element to get the attribute on
+		// name: String
+		//		the name of the attribute to get.
+		// returns:
+		//		the value of the requested attribute or null if that attribute does not have a specified or
+		//		default value;
+		//
+		// example:
+		//	|	// get the current value of the "foo" attribute on a node
+		//	|	dojo.getAttr(dojo.byId("nodeId"), "foo");
+		//	|	// or we can just pass the id:
+		//	|	dojo.getAttr("nodeId", "foo");
+
+		node = dom.byId(node);
+		var lc = name.toLowerCase(),
+			propName = prop.names[lc] || name,
+			forceProp = forcePropNames[propName],
+			value = node[propName];		// should we access this attribute via a property or via getAttribute()?
+
+		if(forceProp && typeof value != "undefined"){
+			// node's property
+			return value;	// Anything
+		}
+		if(propName != "href" && (typeof value == "boolean" || lang.isFunction(value))){
+			// node's property
+			return value;	// Anything
+		}
+		// node's attribute
+		// we need _hasAttr() here to guard against IE returning a default value
+		var attrName = attrNames[lc] || name;
+		return _hasAttr(node, attrName) ? node.getAttribute(attrName) : null; // Anything
+	};
+
+	exports.set = function setAttr(/*DOMNode|String*/ node, /*String|Object*/ name, /*String?*/ value){
+		// summary:
+		//		Sets an attribute on an HTML element.
+		// description:
+		//		Handles normalized setting of attributes on DOM Nodes.
+		//
+		//		When passing functions as values, note that they will not be
+		//		directly assigned to slots on the node, but rather the default
+		//		behavior will be removed and the new behavior will be added
+		//		using `dojo.connect()`, meaning that event handler properties
+		//		will be normalized and that some caveats with regards to
+		//		non-standard behaviors for onsubmit apply. Namely that you
+		//		should cancel form submission using `dojo.stopEvent()` on the
+		//		passed event object instead of returning a boolean value from
+		//		the handler itself.
+		// node: DOMNode|String
+		//		id or reference to the element to set the attribute on
+		// name: String|Object
+		//		the name of the attribute to set, or a hash of key-value pairs to set.
+		// value: String?
+		//		the value to set for the attribute, if the name is a string.
+		// returns:
+		//		the DOM node
+		//
+		// example:
+		//	|	// use attr() to set the tab index
+		//	|	dojo.setAttr("nodeId", "tabIndex", 3);
+		//
+		// example:
+		//	Set multiple values at once, including event handlers:
+		//	|	dojo.setAttr("formId", {
+		//	|		"foo": "bar",
+		//	|		"tabIndex": -1,
+		//	|		"method": "POST",
+		//	|		"onsubmit": function(e){
+		//	|			// stop submitting the form. Note that the IE behavior
+		//	|			// of returning true or false will have no effect here
+		//	|			// since our handler is connect()ed to the built-in
+		//	|			// onsubmit behavior and so we need to use
+		//	|			// dojo.stopEvent() to ensure that the submission
+		//	|			// doesn't proceed.
+		//	|			dojo.stopEvent(e);
+		//	|
+		//	|			// submit the form with Ajax
+		//	|			dojo.xhrPost({ form: "formId" });
+		//	|		}
+		//	|	});
+		//
+		// example:
+		//	Style is s special case: Only set with an object hash of styles
+		//	|	dojo.setAttr("someNode",{
+		//	|		id:"bar",
+		//	|		style:{
+		//	|			width:"200px", height:"100px", color:"#000"
+		//	|		}
+		//	|	});
+		//
+		// example:
+		//	Again, only set style as an object hash of styles:
+		//	|	var obj = { color:"#fff", backgroundColor:"#000" };
+		//	|	dojo.setAttr("someNode", "style", obj);
+		//	|
+		//	|	// though shorter to use `dojo.style()` in this case:
+		//	|	dojo.setStyle("someNode", obj);
+
+		node = dom.byId(node);
+		if(arguments.length == 2){ // inline'd type check
+			// the object form of setter: the 2nd argument is a dictionary
+			for(var x in name){
+				exports.set(node, x, name[x]);
+			}
+			return node; // DomNode
+		}
+		var lc = name.toLowerCase(),
+			propName = prop.names[lc] || name,
+			forceProp = forcePropNames[propName];
+		if(propName == "style" && typeof value != "string"){ // inline'd type check
+			// special case: setting a style
+			style.set(node, value);
+			return node; // DomNode
+		}
+		if(forceProp || typeof value == "boolean" || lang.isFunction(value)){
+			return prop.set(node, name, value);
+		}
+		// node's attribute
+		node.setAttribute(attrNames[lc] || name, value);
+		return node; // DomNode
+	};
+
+	exports.remove = function removeAttr(/*DOMNode|String*/ node, /*String*/ name){
+		// summary:
+		//		Removes an attribute from an HTML element.
+		// node: DOMNode|String
+		//		id or reference to the element to remove the attribute from
+		// name: String
+		//		the name of the attribute to remove
+
+		dom.byId(node).removeAttribute(attrNames[name.toLowerCase()] || name);
+	};
+
+	exports.getNodeProp = function getNodeProp(/*DomNode|String*/ node, /*String*/ name){
+		// summary:
+		//		Returns an effective value of a property or an attribute.
+		// node: DOMNode|String
+		//		id or reference to the element to remove the attribute from
+		// name: String
+		//		the name of the attribute
+		// returns:
+		//		the value of the attribute
+
+		node = dom.byId(node);
+		var lc = name.toLowerCase(), propName = prop.names[lc] || name;
+		if((propName in node) && propName != "href"){
+			// node's property
+			return node[propName];	// Anything
+		}
+		// node's attribute
+		var attrName = attrNames[lc] || name;
+		return _hasAttr(node, attrName) ? node.getAttribute(attrName) : null; // Anything
+	};
+});

debian/missing-sources/dojo/dom-class.js

@@ -0,0 +1,326 @@
+define(["./_base/lang", "./_base/array", "./dom"], function(lang, array, dom){
+	// module:
+	//		dojo/dom-class
+
+	var className = "className";
+
+	/* Part I of classList-based implementation is preserved here for posterity
+	var classList = "classList";
+	has.add("dom-classList", function(){
+		return classList in document.createElement("p");
+	});
+	*/
+
+	// =============================
+	// (CSS) Class Functions
+	// =============================
+
+	var cls, // exports object
+		spaces = /\s+/, a1 = [""];
+
+	function str2array(s){
+		if(typeof s == "string" || s instanceof String){
+			if(s && !spaces.test(s)){
+				a1[0] = s;
+				return a1;
+			}
+			var a = s.split(spaces);
+			if(a.length && !a[0]){
+				a.shift();
+			}
+			if(a.length && !a[a.length - 1]){
+				a.pop();
+			}
+			return a;
+		}
+		// assumed to be an array
+		if(!s){
+			return [];
+		}
+		return array.filter(s, function(x){ return x; });
+	}
+
+	/* Part II of classList-based implementation is preserved here for posterity
+	if(has("dom-classList")){
+		// new classList version
+		cls = {
+			contains: function containsClass(node, classStr){
+				var clslst = classStr && dom.byId(node)[classList];
+				return clslst && clslst.contains(classStr); // Boolean
+			},
+
+			add: function addClass(node, classStr){
+				node = dom.byId(node);
+				classStr = str2array(classStr);
+				for(var i = 0, len = classStr.length; i < len; ++i){
+					node[classList].add(classStr[i]);
+				}
+			},
+
+			remove: function removeClass(node, classStr){
+				node = dom.byId(node);
+				if(classStr === undefined){
+					node[className] = "";
+				}else{
+					classStr = str2array(classStr);
+					for(var i = 0, len = classStr.length; i < len; ++i){
+						node[classList].remove(classStr[i]);
+					}
+				}
+			},
+
+			replace: function replaceClass(node, addClassStr, removeClassStr){
+				node = dom.byId(node);
+				if(removeClassStr === undefined){
+					node[className] = "";
+				}else{
+					removeClassStr = str2array(removeClassStr);
+					for(var i = 0, len = removeClassStr.length; i < len; ++i){
+						node[classList].remove(removeClassStr[i]);
+					}
+				}
+				addClassStr = str2array(addClassStr);
+				for(i = 0, len = addClassStr.length; i < len; ++i){
+					node[classList].add(addClassStr[i]);
+				}
+			},
+
+			toggle: function toggleClass(node, classStr, condition){
+				node = dom.byId(node);
+				if(condition === undefined){
+					classStr = str2array(classStr);
+					for(var i = 0, len = classStr.length; i < len; ++i){
+						node[classList].toggle(classStr[i]);
+					}
+				}else{
+					cls[condition ? "add" : "remove"](node, classStr);
+				}
+				return condition;   // Boolean
+			}
+		}
+	}
+	*/
+
+	// regular DOM version
+	var fakeNode = {};  // for effective replacement
+	cls = {
+		// summary:
+		//		This module defines the core dojo DOM class API.
+
+		contains: function containsClass(/*DomNode|String*/ node, /*String*/ classStr){
+			// summary:
+			//		Returns whether or not the specified classes are a portion of the
+			//		class list currently applied to the node.
+			// node: String|DOMNode
+			//		String ID or DomNode reference to check the class for.
+			// classStr: String
+			//		A string class name to look for.
+			// example:
+			//		Do something if a node with id="someNode" has class="aSillyClassName" present
+			//	|	if(dojo.hasClass("someNode","aSillyClassName")){ ... }
+
+			return ((" " + dom.byId(node)[className] + " ").indexOf(" " + classStr + " ") >= 0); // Boolean
+		},
+
+		add: function addClass(/*DomNode|String*/ node, /*String|Array*/ classStr){
+			// summary:
+			//		Adds the specified classes to the end of the class list on the
+			//		passed node. Will not re-apply duplicate classes.
+			//
+			// node: String|DOMNode
+			//		String ID or DomNode reference to add a class string too
+			//
+			// classStr: String|Array
+			//		A String class name to add, or several space-separated class names,
+			//		or an array of class names.
+			//
+			// example:
+			//		Add a class to some node:
+			//	|	require(["dojo/dom-class"], function(domClass){
+			//	|		domClass.add("someNode", "anewClass");
+			//	|	});
+			//
+			// example:
+			//		Add two classes at once:
+			//	|	require(["dojo/dom-class"], function(domClass){
+			//	|		domClass.add("someNode", "firstClass secondClass");
+			//	|	});
+			//
+			// example:
+			//		Add two classes at once (using array):
+			//	|	require(["dojo/dom-class"], function(domClass){
+			//	|		domClass.add("someNode", ["firstClass", "secondClass"]);
+			//	|	});
+			//
+			// example:
+			//		Available in `dojo/NodeList` for multiple additions
+			//	|	require(["dojo/query"], function(query){
+			//	|		query("ul > li").addClass("firstLevel");
+			//	|	});
+
+			node = dom.byId(node);
+			classStr = str2array(classStr);
+			var cls = node[className], oldLen;
+			cls = cls ? " " + cls + " " : " ";
+			oldLen = cls.length;
+			for(var i = 0, len = classStr.length, c; i < len; ++i){
+				c = classStr[i];
+				if(c && cls.indexOf(" " + c + " ") < 0){
+					cls += c + " ";
+				}
+			}
+			if(oldLen < cls.length){
+				node[className] = cls.substr(1, cls.length - 2);
+			}
+		},
+
+		remove: function removeClass(/*DomNode|String*/ node, /*String|Array?*/ classStr){
+			// summary:
+			//		Removes the specified classes from node. No `contains()`
+			//		check is required.
+			//
+			// node: String|DOMNode
+			//		String ID or DomNode reference to remove the class from.
+			//
+			// classStr: String|Array
+			//		An optional String class name to remove, or several space-separated
+			//		class names, or an array of class names. If omitted, all class names
+			//		will be deleted.
+			//
+			// example:
+			//		Remove a class from some node:
+			//	|	require(["dojo/dom-class"], function(domClass){
+			//	|		domClass.remove("someNode", "firstClass");
+			//	|	});
+			//
+			// example:
+			//		Remove two classes from some node:
+			//	|	require(["dojo/dom-class"], function(domClass){
+			//	|		domClass.remove("someNode", "firstClass secondClass");
+			//	|	});
+			//
+			// example:
+			//		Remove two classes from some node (using array):
+			//	|	require(["dojo/dom-class"], function(domClass){
+			//	|		domClass.remove("someNode", ["firstClass", "secondClass"]);
+			//	|	});
+			//
+			// example:
+			//		Remove all classes from some node:
+			//	|	require(["dojo/dom-class"], function(domClass){
+			//	|		domClass.remove("someNode");
+			//	|	});
+			//
+			// example:
+			//		Available in `dojo/NodeList` for multiple removal
+			//	|	require(["dojo/query"], function(query){
+			//	|		query("ul > li").removeClass("foo");
+			//	|	});
+
+			node = dom.byId(node);
+			var cls;
+			if(classStr !== undefined){
+				classStr = str2array(classStr);
+				cls = " " + node[className] + " ";
+				for(var i = 0, len = classStr.length; i < len; ++i){
+					cls = cls.replace(" " + classStr[i] + " ", " ");
+				}
+				cls = lang.trim(cls);
+			}else{
+				cls = "";
+			}
+			if(node[className] != cls){ node[className] = cls; }
+		},
+
+		replace: function replaceClass(/*DomNode|String*/ node, /*String|Array*/ addClassStr, /*String|Array?*/ removeClassStr){
+			// summary:
+			//		Replaces one or more classes on a node if not present.
+			//		Operates more quickly than calling dojo.removeClass and dojo.addClass
+			//
+			// node: String|DOMNode
+			//		String ID or DomNode reference to remove the class from.
+			//
+			// addClassStr: String|Array
+			//		A String class name to add, or several space-separated class names,
+			//		or an array of class names.
+			//
+			// removeClassStr: String|Array?
+			//		A String class name to remove, or several space-separated class names,
+			//		or an array of class names.
+			//
+			// example:
+			//	|	require(["dojo/dom-class"], function(domClass){
+			//	|		domClass.replace("someNode", "add1 add2", "remove1 remove2");
+			//	|	});
+			//
+			// example:
+			//	Replace all classes with addMe
+			//	|	require(["dojo/dom-class"], function(domClass){
+			//	|		domClass.replace("someNode", "addMe");
+			//	|	});
+			//
+			// example:
+			//	Available in `dojo/NodeList` for multiple toggles
+			//	|	require(["dojo/query"], function(query){
+			//	|		query(".findMe").replaceClass("addMe", "removeMe");
+			//	|	});
+
+			node = dom.byId(node);
+			fakeNode[className] = node[className];
+			cls.remove(fakeNode, removeClassStr);
+			cls.add(fakeNode, addClassStr);
+			if(node[className] !== fakeNode[className]){
+				node[className] = fakeNode[className];
+			}
+		},
+
+		toggle: function toggleClass(/*DomNode|String*/ node, /*String|Array*/ classStr, /*Boolean?*/ condition){
+			// summary:
+			//		Adds a class to node if not present, or removes if present.
+			//		Pass a boolean condition if you want to explicitly add or remove.
+			//		Returns the condition that was specified directly or indirectly.
+			//
+			// node: String|DOMNode
+			//		String ID or DomNode reference to toggle a class string
+			//
+			// classStr: String|Array
+			//		A String class name to toggle, or several space-separated class names,
+			//		or an array of class names.
+			//
+			// condition:
+			//		If passed, true means to add the class, false means to remove.
+			//		Otherwise dojo.hasClass(node, classStr) is used to detect the class presence.
+			//
+			// example:
+			//	|	require(["dojo/dom-class"], function(domClass){
+			//	|		domClass.toggle("someNode", "hovered");
+			//	|	});
+			//
+			// example:
+			//		Forcefully add a class
+			//	|	require(["dojo/dom-class"], function(domClass){
+			//	|		domClass.toggle("someNode", "hovered", true);
+			//	|	});
+			//
+			// example:
+			//		Available in `dojo/NodeList` for multiple toggles
+			//	|	require(["dojo/query"], function(query){
+			//	|		query(".toggleMe").toggleClass("toggleMe");
+			//	|	});
+
+			node = dom.byId(node);
+			if(condition === undefined){
+				classStr = str2array(classStr);
+				for(var i = 0, len = classStr.length, c; i < len; ++i){
+					c = classStr[i];
+					cls[cls.contains(node, c) ? "remove" : "add"](node, c);
+				}
+			}else{
+				cls[condition ? "add" : "remove"](node, classStr);
+			}
+			return condition;   // Boolean
+		}
+	};
+
+	return cls;
+});

debian/missing-sources/dojo/dom-construct.js

@@ -0,0 +1,360 @@
+define(["exports", "./_base/kernel", "./sniff", "./_base/window", "./dom", "./dom-attr"],
+		function(exports, dojo, has, win, dom, attr){
+	// module:
+	//		dojo/dom-construct
+	// summary:
+	//		This module defines the core dojo DOM construction API.
+
+	// TODOC: summary not showing up in output, see https://github.com/csnover/js-doc-parse/issues/42
+
+	// support stuff for toDom()
+	var tagWrap = {
+			option: ["select"],
+			tbody: ["table"],
+			thead: ["table"],
+			tfoot: ["table"],
+			tr: ["table", "tbody"],
+			td: ["table", "tbody", "tr"],
+			th: ["table", "thead", "tr"],
+			legend: ["fieldset"],
+			caption: ["table"],
+			colgroup: ["table"],
+			col: ["table", "colgroup"],
+			li: ["ul"]
+		},
+		reTag = /<\s*([\w\:]+)/,
+		masterNode = {}, masterNum = 0,
+		masterName = "__" + dojo._scopeName + "ToDomId";
+
+	// generate start/end tag strings to use
+	// for the injection for each special tag wrap case.
+	for(var param in tagWrap){
+		if(tagWrap.hasOwnProperty(param)){
+			var tw = tagWrap[param];
+			tw.pre = param == "option" ? '<select multiple="multiple">' : "<" + tw.join("><") + ">";
+			tw.post = "</" + tw.reverse().join("></") + ">";
+			// the last line is destructive: it reverses the array,
+			// but we don't care at this point
+		}
+	}
+
+	var html5domfix;
+	if(has("ie") <= 8){
+		html5domfix = function(doc){
+			doc.__dojo_html5_tested = "yes";
+			var div = create('div', {innerHTML: "<nav>a</nav>", style: {visibility: "hidden"}}, doc.body);
+			if(div.childNodes.length !== 1){
+				('abbr article aside audio canvas details figcaption figure footer header ' +
+				'hgroup mark meter nav output progress section summary time video').replace(
+					/\b\w+\b/g, function(n){
+						doc.createElement(n);
+					}
+				);
+			}
+			destroy(div);
+		}
+	}
+
+	function _insertBefore(/*DomNode*/ node, /*DomNode*/ ref){
+		var parent = ref.parentNode;
+		if(parent){
+			parent.insertBefore(node, ref);
+		}
+	}
+
+	function _insertAfter(/*DomNode*/ node, /*DomNode*/ ref){
+		// summary:
+		//		Try to insert node after ref
+		var parent = ref.parentNode;
+		if(parent){
+			if(parent.lastChild == ref){
+				parent.appendChild(node);
+			}else{
+				parent.insertBefore(node, ref.nextSibling);
+			}
+		}
+	}
+
+	exports.toDom = function toDom(frag, doc){
+		// summary:
+		//		instantiates an HTML fragment returning the corresponding DOM.
+		// frag: String
+		//		the HTML fragment
+		// doc: DocumentNode?
+		//		optional document to use when creating DOM nodes, defaults to
+		//		dojo.doc if not specified.
+		// returns:
+		//		Document fragment, unless it's a single node in which case it returns the node itself
+		// example:
+		//		Create a table row:
+		//	|	var tr = dojo.toDom("<tr><td>First!</td></tr>");
+
+		doc = doc || win.doc;
+		var masterId = doc[masterName];
+		if(!masterId){
+			doc[masterName] = masterId = ++masterNum + "";
+			masterNode[masterId] = doc.createElement("div");
+		}
+
+		if(has("ie") <= 8){
+			if(!doc.__dojo_html5_tested && doc.body){
+				html5domfix(doc);
+			}
+		}
+
+		// make sure the frag is a string.
+		frag += "";
+
+		// find the starting tag, and get node wrapper
+		var match = frag.match(reTag),
+			tag = match ? match[1].toLowerCase() : "",
+			master = masterNode[masterId],
+			wrap, i, fc, df;
+		if(match && tagWrap[tag]){
+			wrap = tagWrap[tag];
+			master.innerHTML = wrap.pre + frag + wrap.post;
+			for(i = wrap.length; i; --i){
+				master = master.firstChild;
+			}
+		}else{
+			master.innerHTML = frag;
+		}
+
+		// one node shortcut => return the node itself
+		if(master.childNodes.length == 1){
+			return master.removeChild(master.firstChild); // DOMNode
+		}
+
+		// return multiple nodes as a document fragment
+		df = doc.createDocumentFragment();
+		while((fc = master.firstChild)){ // intentional assignment
+			df.appendChild(fc);
+		}
+		return df; // DocumentFragment
+	};
+
+	exports.place = function place(/*DOMNode|String*/ node, /*DOMNode|String*/ refNode, /*String|Number?*/ position){
+		// summary:
+		//		Attempt to insert node into the DOM, choosing from various positioning options.
+		//		Returns the first argument resolved to a DOM node.
+		// node: DOMNode|String
+		//		id or node reference, or HTML fragment starting with "<" to place relative to refNode
+		// refNode: DOMNode|String
+		//		id or node reference to use as basis for placement
+		// position: String|Number?
+		//		string noting the position of node relative to refNode or a
+		//		number indicating the location in the childNodes collection of refNode.
+		//		Accepted string values are:
+		//
+		//		- before
+		//		- after
+		//		- replace
+		//		- only
+		//		- first
+		//		- last
+		//
+		//		"first" and "last" indicate positions as children of refNode, "replace" replaces refNode,
+		//		"only" replaces all children.  position defaults to "last" if not specified
+		// returns: DOMNode
+		//		Returned values is the first argument resolved to a DOM node.
+		//
+		//		.place() is also a method of `dojo/NodeList`, allowing `dojo.query` node lookups.
+		// example:
+		//		Place a node by string id as the last child of another node by string id:
+		//	|	dojo.place("someNode", "anotherNode");
+		// example:
+		//		Place a node by string id before another node by string id
+		//	|	dojo.place("someNode", "anotherNode", "before");
+		// example:
+		//		Create a Node, and place it in the body element (last child):
+		//	|	dojo.place("<div></div>", dojo.body());
+		// example:
+		//		Put a new LI as the first child of a list by id:
+		//	|	dojo.place("<li></li>", "someUl", "first");
+
+		refNode = dom.byId(refNode);
+		if(typeof node == "string"){ // inline'd type check
+			node = /^\s*</.test(node) ? exports.toDom(node, refNode.ownerDocument) : dom.byId(node);
+		}
+		if(typeof position == "number"){ // inline'd type check
+			var cn = refNode.childNodes;
+			if(!cn.length || cn.length <= position){
+				refNode.appendChild(node);
+			}else{
+				_insertBefore(node, cn[position < 0 ? 0 : position]);
+			}
+		}else{
+			switch(position){
+				case "before":
+					_insertBefore(node, refNode);
+					break;
+				case "after":
+					_insertAfter(node, refNode);
+					break;
+				case "replace":
+					refNode.parentNode.replaceChild(node, refNode);
+					break;
+				case "only":
+					exports.empty(refNode);
+					refNode.appendChild(node);
+					break;
+				case "first":
+					if(refNode.firstChild){
+						_insertBefore(node, refNode.firstChild);
+						break;
+					}
+					// else fallthrough...
+				default: // aka: last
+					refNode.appendChild(node);
+			}
+		}
+		return node; // DomNode
+	};
+
+	var create = exports.create = function create(/*DOMNode|String*/ tag, /*Object*/ attrs, /*DOMNode|String?*/ refNode, /*String?*/ pos){
+		// summary:
+		//		Create an element, allowing for optional attribute decoration
+		//		and placement.
+		// description:
+		//		A DOM Element creation function. A shorthand method for creating a node or
+		//		a fragment, and allowing for a convenient optional attribute setting step,
+		//		as well as an optional DOM placement reference.
+		//
+		//		Attributes are set by passing the optional object through `dojo.setAttr`.
+		//		See `dojo.setAttr` for noted caveats and nuances, and API if applicable.
+		//
+		//		Placement is done via `dojo.place`, assuming the new node to be the action
+		//		node, passing along the optional reference node and position.
+		// tag: DOMNode|String
+		//		A string of the element to create (eg: "div", "a", "p", "li", "script", "br"),
+		//		or an existing DOM node to process.
+		// attrs: Object
+		//		An object-hash of attributes to set on the newly created node.
+		//		Can be null, if you don't want to set any attributes/styles.
+		//		See: `dojo.setAttr` for a description of available attributes.
+		// refNode: DOMNode|String?
+		//		Optional reference node. Used by `dojo.place` to place the newly created
+		//		node somewhere in the dom relative to refNode. Can be a DomNode reference
+		//		or String ID of a node.
+		// pos: String?
+		//		Optional positional reference. Defaults to "last" by way of `dojo.place`,
+		//		though can be set to "first","after","before","last", "replace" or "only"
+		//		to further control the placement of the new node relative to the refNode.
+		//		'refNode' is required if a 'pos' is specified.
+		// example:
+		//		Create a DIV:
+		//	|	var n = dojo.create("div");
+		//
+		// example:
+		//		Create a DIV with content:
+		//	|	var n = dojo.create("div", { innerHTML:"<p>hi</p>" });
+		//
+		// example:
+		//		Place a new DIV in the BODY, with no attributes set
+		//	|	var n = dojo.create("div", null, dojo.body());
+		//
+		// example:
+		//		Create an UL, and populate it with LI's. Place the list as the first-child of a
+		//		node with id="someId":
+		//	|	var ul = dojo.create("ul", null, "someId", "first");
+		//	|	var items = ["one", "two", "three", "four"];
+		//	|	dojo.forEach(items, function(data){
+		//	|		dojo.create("li", { innerHTML: data }, ul);
+		//	|	});
+		//
+		// example:
+		//		Create an anchor, with an href. Place in BODY:
+		//	|	dojo.create("a", { href:"foo.html", title:"Goto FOO!" }, dojo.body());
+		//
+		// example:
+		//		Create a `dojo/NodeList()` from a new element (for syntactic sugar):
+		//	|	dojo.query(dojo.create('div'))
+		//	|		.addClass("newDiv")
+		//	|		.onclick(function(e){ console.log('clicked', e.target) })
+		//	|		.place("#someNode"); // redundant, but cleaner.
+
+		var doc = win.doc;
+		if(refNode){
+			refNode = dom.byId(refNode);
+			doc = refNode.ownerDocument;
+		}
+		if(typeof tag == "string"){ // inline'd type check
+			tag = doc.createElement(tag);
+		}
+		if(attrs){ attr.set(tag, attrs); }
+		if(refNode){ exports.place(tag, refNode, pos); }
+		return tag; // DomNode
+	};
+
+	function _empty(/*DomNode*/ node){
+		if(node.canHaveChildren){
+			try{
+				// fast path
+				node.innerHTML = "";
+				return;
+			}catch(e){
+				// innerHTML is readOnly (e.g. TABLE (sub)elements in quirks mode)
+				// Fall through (saves bytes)
+			}
+		}
+		// SVG/strict elements don't support innerHTML/canHaveChildren, and OBJECT/APPLET elements in quirks node have canHaveChildren=false
+		for(var c; c = node.lastChild;){ // intentional assignment
+			_destroy(c, node); // destroy is better than removeChild so TABLE subelements are removed in proper order
+		}
+	}
+
+	exports.empty = function empty(/*DOMNode|String*/ node){
+		 // summary:
+		 //		safely removes all children of the node.
+		 // node: DOMNode|String
+		 //		a reference to a DOM node or an id.
+		 // example:
+		 //		Destroy node's children byId:
+		 //	|	dojo.empty("someId");
+		 //
+		 // example:
+		 //		Destroy all nodes' children in a list by reference:
+		 //	|	dojo.query(".someNode").forEach(dojo.empty);
+
+		_empty(dom.byId(node));
+	};
+
+
+	function _destroy(/*DomNode*/ node, /*DomNode*/ parent){
+		// in IE quirks, node.canHaveChildren can be false but firstChild can be non-null (OBJECT/APPLET)
+		if(node.firstChild){
+			_empty(node);
+		}
+		if(parent){
+			// removeNode(false) doesn't leak in IE 6+, but removeChild() and removeNode(true) are known to leak under IE 8- while 9+ is TBD.
+			// In IE quirks mode, PARAM nodes as children of OBJECT/APPLET nodes have a removeNode method that does nothing and
+			// the parent node has canHaveChildren=false even though removeChild correctly removes the PARAM children.
+			// In IE, SVG/strict nodes don't have a removeNode method nor a canHaveChildren boolean.
+			has("ie") && parent.canHaveChildren && "removeNode" in node ? node.removeNode(false) : parent.removeChild(node);
+		}
+	}
+	var destroy = exports.destroy = function destroy(/*DOMNode|String*/ node){
+		// summary:
+		//		Removes a node from its parent, clobbering it and all of its
+		//		children.
+		//
+		// description:
+		//		Removes a node from its parent, clobbering it and all of its
+		//		children. Function only works with DomNodes, and returns nothing.
+		//
+		// node: DOMNode|String
+		//		A String ID or DomNode reference of the element to be destroyed
+		//
+		// example:
+		//		Destroy a node byId:
+		//	|	dojo.destroy("someId");
+		//
+		// example:
+		//		Destroy all nodes in a list by reference:
+		//	|	dojo.query(".someNode").forEach(dojo.destroy);
+
+		node = dom.byId(node);
+		if(!node){ return; }
+		_destroy(node, node.parentNode);
+	};
+});

debian/missing-sources/dojo/dom-geometry.js

@@ -0,0 +1,605 @@
+define(["./sniff", "./_base/window","./dom", "./dom-style"],
+		function(has, win, dom, style){
+	// module:
+	//		dojo/dom-geometry
+
+	// the result object
+	var geom = {
+		// summary:
+		//		This module defines the core dojo DOM geometry API.
+	};
+
+	// Box functions will assume this model.
+	// On IE/Opera, BORDER_BOX will be set if the primary document is in quirks mode.
+	// Can be set to change behavior of box setters.
+
+	// can be either:
+	//	"border-box"
+	//	"content-box" (default)
+	geom.boxModel = "content-box";
+
+	// We punt per-node box mode testing completely.
+	// If anybody cares, we can provide an additional (optional) unit
+	// that overrides existing code to include per-node box sensitivity.
+
+	// Opera documentation claims that Opera 9 uses border-box in BackCompat mode.
+	// but experiments (Opera 9.10.8679 on Windows Vista) indicate that it actually continues to use content-box.
+	// IIRC, earlier versions of Opera did in fact use border-box.
+	// Opera guys, this is really confusing. Opera being broken in quirks mode is not our fault.
+
+	if(has("ie") /*|| has("opera")*/){
+		// client code may have to adjust if compatMode varies across iframes
+		geom.boxModel = document.compatMode == "BackCompat" ? "border-box" : "content-box";
+	}
+
+	geom.getPadExtents = function getPadExtents(/*DomNode*/ node, /*Object*/ computedStyle){
+		// summary:
+		//		Returns object with special values specifically useful for node
+		//		fitting.
+		// description:
+		//		Returns an object with `w`, `h`, `l`, `t` properties:
+		//	|		l/t/r/b = left/top/right/bottom padding (respectively)
+		//	|		w = the total of the left and right padding
+		//	|		h = the total of the top and bottom padding
+		//		If 'node' has position, l/t forms the origin for child nodes.
+		//		The w/h are used for calculating boxes.
+		//		Normally application code will not need to invoke this
+		//		directly, and will use the ...box... functions instead.
+		// node: DOMNode
+		// computedStyle: Object?
+		//		This parameter accepts computed styles object.
+		//		If this parameter is omitted, the functions will call
+		//		dojo.getComputedStyle to get one. It is a better way, calling
+		//		dojo.computedStyle once, and then pass the reference to this
+		//		computedStyle parameter. Wherever possible, reuse the returned
+		//		object of dojo/dom-style.getComputedStyle().
+
+		node = dom.byId(node);
+		var s = computedStyle || style.getComputedStyle(node), px = style.toPixelValue,
+			l = px(node, s.paddingLeft), t = px(node, s.paddingTop), r = px(node, s.paddingRight), b = px(node, s.paddingBottom);
+		return {l: l, t: t, r: r, b: b, w: l + r, h: t + b};
+	};
+
+	var none = "none";
+
+	geom.getBorderExtents = function getBorderExtents(/*DomNode*/ node, /*Object*/ computedStyle){
+		// summary:
+		//		returns an object with properties useful for noting the border
+		//		dimensions.
+		// description:
+		//		- l/t/r/b = the sum of left/top/right/bottom border (respectively)
+		//		- w = the sum of the left and right border
+		//		- h = the sum of the top and bottom border
+		//
+		//		The w/h are used for calculating boxes.
+		//		Normally application code will not need to invoke this
+		//		directly, and will use the ...box... functions instead.
+		// node: DOMNode
+		// computedStyle: Object?
+		//		This parameter accepts computed styles object.
+		//		If this parameter is omitted, the functions will call
+		//		dojo.getComputedStyle to get one. It is a better way, calling
+		//		dojo.computedStyle once, and then pass the reference to this
+		//		computedStyle parameter. Wherever possible, reuse the returned
+		//		object of dojo/dom-style.getComputedStyle().
+
+		node = dom.byId(node);
+		var px = style.toPixelValue, s = computedStyle || style.getComputedStyle(node),
+			l = s.borderLeftStyle != none ? px(node, s.borderLeftWidth) : 0,
+			t = s.borderTopStyle != none ? px(node, s.borderTopWidth) : 0,
+			r = s.borderRightStyle != none ? px(node, s.borderRightWidth) : 0,
+			b = s.borderBottomStyle != none ? px(node, s.borderBottomWidth) : 0;
+		return {l: l, t: t, r: r, b: b, w: l + r, h: t + b};
+	};
+
+	geom.getPadBorderExtents = function getPadBorderExtents(/*DomNode*/ node, /*Object*/ computedStyle){
+		// summary:
+		//		Returns object with properties useful for box fitting with
+		//		regards to padding.
+		// description:
+		//		- l/t/r/b = the sum of left/top/right/bottom padding and left/top/right/bottom border (respectively)
+		//		- w = the sum of the left and right padding and border
+		//		- h = the sum of the top and bottom padding and border
+		//
+		//		The w/h are used for calculating boxes.
+		//		Normally application code will not need to invoke this
+		//		directly, and will use the ...box... functions instead.
+		// node: DOMNode
+		// computedStyle: Object?
+		//		This parameter accepts computed styles object.
+		//		If this parameter is omitted, the functions will call
+		//		dojo.getComputedStyle to get one. It is a better way, calling
+		//		dojo.computedStyle once, and then pass the reference to this
+		//		computedStyle parameter. Wherever possible, reuse the returned
+		//		object of dojo/dom-style.getComputedStyle().
+
+		node = dom.byId(node);
+		var s = computedStyle || style.getComputedStyle(node),
+			p = geom.getPadExtents(node, s),
+			b = geom.getBorderExtents(node, s);
+		return {
+			l: p.l + b.l,
+			t: p.t + b.t,
+			r: p.r + b.r,
+			b: p.b + b.b,
+			w: p.w + b.w,
+			h: p.h + b.h
+		};
+	};
+
+	geom.getMarginExtents = function getMarginExtents(node, computedStyle){
+		// summary:
+		//		returns object with properties useful for box fitting with
+		//		regards to box margins (i.e., the outer-box).
+		//
+		//		- l/t = marginLeft, marginTop, respectively
+		//		- w = total width, margin inclusive
+		//		- h = total height, margin inclusive
+		//
+		//		The w/h are used for calculating boxes.
+		//		Normally application code will not need to invoke this
+		//		directly, and will use the ...box... functions instead.
+		// node: DOMNode
+		// computedStyle: Object?
+		//		This parameter accepts computed styles object.
+		//		If this parameter is omitted, the functions will call
+		//		dojo.getComputedStyle to get one. It is a better way, calling
+		//		dojo.computedStyle once, and then pass the reference to this
+		//		computedStyle parameter. Wherever possible, reuse the returned
+		//		object of dojo/dom-style.getComputedStyle().
+
+		node = dom.byId(node);
+		var s = computedStyle || style.getComputedStyle(node), px = style.toPixelValue,
+			l = px(node, s.marginLeft), t = px(node, s.marginTop), r = px(node, s.marginRight), b = px(node, s.marginBottom);
+		return {l: l, t: t, r: r, b: b, w: l + r, h: t + b};
+	};
+
+	// Box getters work in any box context because offsetWidth/clientWidth
+	// are invariant wrt box context
+	//
+	// They do *not* work for display: inline objects that have padding styles
+	// because the user agent ignores padding (it's bogus styling in any case)
+	//
+	// Be careful with IMGs because they are inline or block depending on
+	// browser and browser mode.
+
+	// Although it would be easier to read, there are not separate versions of
+	// _getMarginBox for each browser because:
+	// 1. the branching is not expensive
+	// 2. factoring the shared code wastes cycles (function call overhead)
+	// 3. duplicating the shared code wastes bytes
+
+	geom.getMarginBox = function getMarginBox(/*DomNode*/ node, /*Object*/ computedStyle){
+		// summary:
+		//		returns an object that encodes the width, height, left and top
+		//		positions of the node's margin box.
+		// node: DOMNode
+		// computedStyle: Object?
+		//		This parameter accepts computed styles object.
+		//		If this parameter is omitted, the functions will call
+		//		dojo.getComputedStyle to get one. It is a better way, calling
+		//		dojo.computedStyle once, and then pass the reference to this
+		//		computedStyle parameter. Wherever possible, reuse the returned
+		//		object of dojo/dom-style.getComputedStyle().
+
+		node = dom.byId(node);
+		var s = computedStyle || style.getComputedStyle(node), me = geom.getMarginExtents(node, s),
+			l = node.offsetLeft - me.l, t = node.offsetTop - me.t, p = node.parentNode, px = style.toPixelValue, pcs;
+		if(has("mozilla")){
+			// Mozilla:
+			// If offsetParent has a computed overflow != visible, the offsetLeft is decreased
+			// by the parent's border.
+			// We don't want to compute the parent's style, so instead we examine node's
+			// computed left/top which is more stable.
+			var sl = parseFloat(s.left), st = parseFloat(s.top);
+			if(!isNaN(sl) && !isNaN(st)){
+				l = sl;
+				t = st;
+			}else{
+				// If child's computed left/top are not parseable as a number (e.g. "auto"), we
+				// have no choice but to examine the parent's computed style.
+				if(p && p.style){
+					pcs = style.getComputedStyle(p);
+					if(pcs.overflow != "visible"){
+						l += pcs.borderLeftStyle != none ? px(node, pcs.borderLeftWidth) : 0;
+						t += pcs.borderTopStyle != none ? px(node, pcs.borderTopWidth) : 0;
+					}
+				}
+			}
+		}else if(has("opera") || (has("ie") == 8 && !has("quirks"))){
+			// On Opera and IE 8, offsetLeft/Top includes the parent's border
+			if(p){
+				pcs = style.getComputedStyle(p);
+				l -= pcs.borderLeftStyle != none ? px(node, pcs.borderLeftWidth) : 0;
+				t -= pcs.borderTopStyle != none ? px(node, pcs.borderTopWidth) : 0;
+			}
+		}
+		return {l: l, t: t, w: node.offsetWidth + me.w, h: node.offsetHeight + me.h};
+	};
+
+	geom.getContentBox = function getContentBox(node, computedStyle){
+		// summary:
+		//		Returns an object that encodes the width, height, left and top
+		//		positions of the node's content box, irrespective of the
+		//		current box model.
+		// node: DOMNode
+		// computedStyle: Object?
+		//		This parameter accepts computed styles object.
+		//		If this parameter is omitted, the functions will call
+		//		dojo.getComputedStyle to get one. It is a better way, calling
+		//		dojo.computedStyle once, and then pass the reference to this
+		//		computedStyle parameter. Wherever possible, reuse the returned
+		//		object of dojo/dom-style.getComputedStyle().
+
+		// clientWidth/Height are important since the automatically account for scrollbars
+		// fallback to offsetWidth/Height for special cases (see #3378)
+		node = dom.byId(node);
+		var s = computedStyle || style.getComputedStyle(node), w = node.clientWidth, h,
+			pe = geom.getPadExtents(node, s), be = geom.getBorderExtents(node, s);
+		if(!w){
+			w = node.offsetWidth;
+			h = node.offsetHeight;
+		}else{
+			h = node.clientHeight;
+			be.w = be.h = 0;
+		}
+		// On Opera, offsetLeft includes the parent's border
+		if(has("opera")){
+			pe.l += be.l;
+			pe.t += be.t;
+		}
+		return {l: pe.l, t: pe.t, w: w - pe.w - be.w, h: h - pe.h - be.h};
+	};
+
+	// Box setters depend on box context because interpretation of width/height styles
+	// vary wrt box context.
+	//
+	// The value of boxModel is used to determine box context.
+	// boxModel can be set directly to change behavior.
+	//
+	// Beware of display: inline objects that have padding styles
+	// because the user agent ignores padding (it's a bogus setup anyway)
+	//
+	// Be careful with IMGs because they are inline or block depending on
+	// browser and browser mode.
+	//
+	// Elements other than DIV may have special quirks, like built-in
+	// margins or padding, or values not detectable via computedStyle.
+	// In particular, margins on TABLE do not seems to appear
+	// at all in computedStyle on Mozilla.
+
+	function setBox(/*DomNode*/ node, /*Number?*/ l, /*Number?*/ t, /*Number?*/ w, /*Number?*/ h, /*String?*/ u){
+		// summary:
+		//		sets width/height/left/top in the current (native) box-model
+		//		dimensions. Uses the unit passed in u.
+		// node:
+		//		DOM Node reference. Id string not supported for performance
+		//		reasons.
+		// l:
+		//		left offset from parent.
+		// t:
+		//		top offset from parent.
+		// w:
+		//		width in current box model.
+		// h:
+		//		width in current box model.
+		// u:
+		//		unit measure to use for other measures. Defaults to "px".
+		u = u || "px";
+		var s = node.style;
+		if(!isNaN(l)){
+			s.left = l + u;
+		}
+		if(!isNaN(t)){
+			s.top = t + u;
+		}
+		if(w >= 0){
+			s.width = w + u;
+		}
+		if(h >= 0){
+			s.height = h + u;
+		}
+	}
+
+	function isButtonTag(/*DomNode*/ node){
+		// summary:
+		//		True if the node is BUTTON or INPUT.type="button".
+		return node.tagName.toLowerCase() == "button" ||
+			node.tagName.toLowerCase() == "input" && (node.getAttribute("type") || "").toLowerCase() == "button"; // boolean
+	}
+
+	function usesBorderBox(/*DomNode*/ node){
+		// summary:
+		//		True if the node uses border-box layout.
+
+		// We could test the computed style of node to see if a particular box
+		// has been specified, but there are details and we choose not to bother.
+
+		// TABLE and BUTTON (and INPUT type=button) are always border-box by default.
+		// If you have assigned a different box to either one via CSS then
+		// box functions will break.
+
+		return geom.boxModel == "border-box" || node.tagName.toLowerCase() == "table" || isButtonTag(node); // boolean
+	}
+
+	geom.setContentSize = function setContentSize(/*DomNode*/ node, /*Object*/ box, /*Object*/ computedStyle){
+		// summary:
+		//		Sets the size of the node's contents, irrespective of margins,
+		//		padding, or borders.
+		// node: DOMNode
+		// box: Object
+		//		hash with optional "w", and "h" properties for "width", and "height"
+		//		respectively. All specified properties should have numeric values in whole pixels.
+		// computedStyle: Object?
+		//		This parameter accepts computed styles object.
+		//		If this parameter is omitted, the functions will call
+		//		dojo.getComputedStyle to get one. It is a better way, calling
+		//		dojo.computedStyle once, and then pass the reference to this
+		//		computedStyle parameter. Wherever possible, reuse the returned
+		//		object of dojo/dom-style.getComputedStyle().
+
+		node = dom.byId(node);
+		var w = box.w, h = box.h;
+		if(usesBorderBox(node)){
+			var pb = geom.getPadBorderExtents(node, computedStyle);
+			if(w >= 0){
+				w += pb.w;
+			}
+			if(h >= 0){
+				h += pb.h;
+			}
+		}
+		setBox(node, NaN, NaN, w, h);
+	};
+
+	var nilExtents = {l: 0, t: 0, w: 0, h: 0};
+
+	geom.setMarginBox = function setMarginBox(/*DomNode*/ node, /*Object*/ box, /*Object*/ computedStyle){
+		// summary:
+		//		sets the size of the node's margin box and placement
+		//		(left/top), irrespective of box model. Think of it as a
+		//		passthrough to setBox that handles box-model vagaries for
+		//		you.
+		// node: DOMNode
+		// box: Object
+		//		hash with optional "l", "t", "w", and "h" properties for "left", "right", "width", and "height"
+		//		respectively. All specified properties should have numeric values in whole pixels.
+		// computedStyle: Object?
+		//		This parameter accepts computed styles object.
+		//		If this parameter is omitted, the functions will call
+		//		dojo.getComputedStyle to get one. It is a better way, calling
+		//		dojo.computedStyle once, and then pass the reference to this
+		//		computedStyle parameter. Wherever possible, reuse the returned
+		//		object of dojo/dom-style.getComputedStyle().
+
+		node = dom.byId(node);
+		var s = computedStyle || style.getComputedStyle(node), w = box.w, h = box.h,
+		// Some elements have special padding, margin, and box-model settings.
+		// To use box functions you may need to set padding, margin explicitly.
+		// Controlling box-model is harder, in a pinch you might set dojo/dom-geometry.boxModel.
+			pb = usesBorderBox(node) ? nilExtents : geom.getPadBorderExtents(node, s),
+			mb = geom.getMarginExtents(node, s);
+		if(has("webkit")){
+			// on Safari (3.1.2), button nodes with no explicit size have a default margin
+			// setting an explicit size eliminates the margin.
+			// We have to swizzle the width to get correct margin reading.
+			if(isButtonTag(node)){
+				var ns = node.style;
+				if(w >= 0 && !ns.width){
+					ns.width = "4px";
+				}
+				if(h >= 0 && !ns.height){
+					ns.height = "4px";
+				}
+			}
+		}
+		if(w >= 0){
+			w = Math.max(w - pb.w - mb.w, 0);
+		}
+		if(h >= 0){
+			h = Math.max(h - pb.h - mb.h, 0);
+		}
+		setBox(node, box.l, box.t, w, h);
+	};
+
+	// =============================
+	// Positioning
+	// =============================
+
+	geom.isBodyLtr = function isBodyLtr(/*Document?*/ doc){
+		// summary:
+		//		Returns true if the current language is left-to-right, and false otherwise.
+		// doc: Document?
+		//		Optional document to query.   If unspecified, use win.doc.
+		// returns: Boolean
+
+		doc = doc || win.doc;
+		return (win.body(doc).dir || doc.documentElement.dir || "ltr").toLowerCase() == "ltr"; // Boolean
+	};
+
+	geom.docScroll = function docScroll(/*Document?*/ doc){
+		// summary:
+		//		Returns an object with {node, x, y} with corresponding offsets.
+		// doc: Document?
+		//		Optional document to query.   If unspecified, use win.doc.
+		// returns: Object
+
+		doc = doc || win.doc;
+		var node = win.doc.parentWindow || win.doc.defaultView;   // use UI window, not dojo.global window.   TODO: use dojo/window::get() except for circular dependency problem
+		return "pageXOffset" in node ? {x: node.pageXOffset, y: node.pageYOffset } :
+			(node = has("quirks") ? win.body(doc) : doc.documentElement) &&
+				{x: geom.fixIeBiDiScrollLeft(node.scrollLeft || 0, doc), y: node.scrollTop || 0 };
+	};
+
+	if(has("ie")){
+		geom.getIeDocumentElementOffset = function getIeDocumentElementOffset(/*Document?*/ doc){
+			// summary:
+			//		returns the offset in x and y from the document body to the
+			//		visual edge of the page for IE
+			// doc: Document?
+			//		Optional document to query.   If unspecified, use win.doc.
+			// description:
+			//		The following values in IE contain an offset:
+			//	|		event.clientX
+			//	|		event.clientY
+			//	|		node.getBoundingClientRect().left
+			//	|		node.getBoundingClientRect().top
+			//		But other position related values do not contain this offset,
+			//		such as node.offsetLeft, node.offsetTop, node.style.left and
+			//		node.style.top. The offset is always (2, 2) in LTR direction.
+			//		When the body is in RTL direction, the offset counts the width
+			//		of left scroll bar's width.  This function computes the actual
+			//		offset.
+
+			//NOTE: assumes we're being called in an IE browser
+
+			doc = doc || win.doc;
+			var de = doc.documentElement; // only deal with HTML element here, position() handles body/quirks
+
+			if(has("ie") < 8){
+				var r = de.getBoundingClientRect(), // works well for IE6+
+					l = r.left, t = r.top;
+				if(has("ie") < 7){
+					l += de.clientLeft;	// scrollbar size in strict/RTL, or,
+					t += de.clientTop;	// HTML border size in strict
+				}
+				return {
+					x: l < 0 ? 0 : l, // FRAME element border size can lead to inaccurate negative values
+					y: t < 0 ? 0 : t
+				};
+			}else{
+				return {
+					x: 0,
+					y: 0
+				};
+			}
+		};
+	}
+
+	geom.fixIeBiDiScrollLeft = function fixIeBiDiScrollLeft(/*Integer*/ scrollLeft, /*Document?*/ doc){
+		// summary:
+		//		In RTL direction, scrollLeft should be a negative value, but IE
+		//		returns a positive one. All codes using documentElement.scrollLeft
+		//		must call this function to fix this error, otherwise the position
+		//		will offset to right when there is a horizontal scrollbar.
+		// scrollLeft: Number
+		// doc: Document?
+		//		Optional document to query.   If unspecified, use win.doc.
+		// returns: Number
+
+		// In RTL direction, scrollLeft should be a negative value, but IE
+		// returns a positive one. All codes using documentElement.scrollLeft
+		// must call this function to fix this error, otherwise the position
+		// will offset to right when there is a horizontal scrollbar.
+
+		doc = doc || win.doc;
+		var ie = has("ie");
+		if(ie && !geom.isBodyLtr(doc)){
+			var qk = has("quirks"),
+				de = qk ? win.body(doc) : doc.documentElement,
+				pwin = win.global;	// TODO: use winUtils.get(doc) after resolving circular dependency b/w dom-geometry.js and dojo/window.js
+			if(ie == 6 && !qk && pwin.frameElement && de.scrollHeight > de.clientHeight){
+				scrollLeft += de.clientLeft; // workaround ie6+strict+rtl+iframe+vertical-scrollbar bug where clientWidth is too small by clientLeft pixels
+			}
+			return (ie < 8 || qk) ? (scrollLeft + de.clientWidth - de.scrollWidth) : -scrollLeft; // Integer
+		}
+		return scrollLeft; // Integer
+	};
+
+	geom.position = function(/*DomNode*/ node, /*Boolean?*/ includeScroll){
+		// summary:
+		//		Gets the position and size of the passed element relative to
+		//		the viewport (if includeScroll==false), or relative to the
+		//		document root (if includeScroll==true).
+		//
+		// description:
+		//		Returns an object of the form:
+		//		`{ x: 100, y: 300, w: 20, h: 15 }`.
+		//		If includeScroll==true, the x and y values will include any
+		//		document offsets that may affect the position relative to the
+		//		viewport.
+		//		Uses the border-box model (inclusive of border and padding but
+		//		not margin).  Does not act as a setter.
+		// node: DOMNode|String
+		// includeScroll: Boolean?
+		// returns: Object
+
+		node = dom.byId(node);
+		var	db = win.body(node.ownerDocument),
+			ret = node.getBoundingClientRect();
+		ret = {x: ret.left, y: ret.top, w: ret.right - ret.left, h: ret.bottom - ret.top};
+
+		if(has("ie") < 9){
+			// On IE<9 there's a 2px offset that we need to adjust for, see dojo.getIeDocumentElementOffset()
+			var offset = geom.getIeDocumentElementOffset(node.ownerDocument);
+
+			// fixes the position in IE, quirks mode
+			ret.x -= offset.x + (has("quirks") ? db.clientLeft + db.offsetLeft : 0);
+			ret.y -= offset.y + (has("quirks") ? db.clientTop + db.offsetTop : 0);
+		}
+
+		// account for document scrolling
+		// if offsetParent is used, ret value already includes scroll position
+		// so we may have to actually remove that value if !includeScroll
+		if(includeScroll){
+			var scroll = geom.docScroll(node.ownerDocument);
+			ret.x += scroll.x;
+			ret.y += scroll.y;
+		}
+
+		return ret; // Object
+	};
+
+	// random "private" functions wildly used throughout the toolkit
+
+	geom.getMarginSize = function getMarginSize(/*DomNode*/ node, /*Object*/ computedStyle){
+		// summary:
+		//		returns an object that encodes the width and height of
+		//		the node's margin box
+		// node: DOMNode|String
+		// computedStyle: Object?
+		//		This parameter accepts computed styles object.
+		//		If this parameter is omitted, the functions will call
+		//		dojo.getComputedStyle to get one. It is a better way, calling
+		//		dojo.computedStyle once, and then pass the reference to this
+		//		computedStyle parameter. Wherever possible, reuse the returned
+		//		object of dojo/dom-style.getComputedStyle().
+
+		node = dom.byId(node);
+		var me = geom.getMarginExtents(node, computedStyle || style.getComputedStyle(node));
+		var size = node.getBoundingClientRect();
+		return {
+			w: (size.right - size.left) + me.w,
+			h: (size.bottom - size.top) + me.h
+		};
+	};
+
+	geom.normalizeEvent = function(event){
+		// summary:
+		//		Normalizes the geometry of a DOM event, normalizing the pageX, pageY,
+		//		offsetX, offsetY, layerX, and layerX properties
+		// event: Object
+		if(!("layerX" in event)){
+			event.layerX = event.offsetX;
+			event.layerY = event.offsetY;
+		}
+		if(!has("dom-addeventlistener")){
+			// old IE version
+			// FIXME: scroll position query is duped from dojo.html to
+			// avoid dependency on that entire module. Now that HTML is in
+			// Base, we should convert back to something similar there.
+			var se = event.target;
+			var doc = (se && se.ownerDocument) || document;
+			// DO NOT replace the following to use dojo.body(), in IE, document.documentElement should be used
+			// here rather than document.body
+			var docBody = has("quirks") ? doc.body : doc.documentElement;
+			var offset = geom.getIeDocumentElementOffset(doc);
+			event.pageX = event.clientX + geom.fixIeBiDiScrollLeft(docBody.scrollLeft || 0, doc) - offset.x;
+			event.pageY = event.clientY + (docBody.scrollTop || 0) - offset.y;
+		}
+	};
+
+	// TODO: evaluate separate getters/setters for position and sizes?
+
+	return geom;
+});

debian/missing-sources/dojo/dom-prop.js

@@ -0,0 +1,180 @@
+define(["exports", "./_base/kernel", "./sniff", "./_base/lang", "./dom", "./dom-style", "./dom-construct", "./_base/connect"],
+		function(exports, dojo, has, lang, dom, style, ctr, conn){
+	// module:
+	//		dojo/dom-prop
+	// summary:
+	//		This module defines the core dojo DOM properties API.
+
+	// TODOC: summary not showing up in output, see https://github.com/csnover/js-doc-parse/issues/42
+
+	// =============================
+	// Element properties Functions
+	// =============================
+
+	// helper to connect events
+	var _evtHdlrMap = {}, _ctr = 0, _attrId = dojo._scopeName + "attrid";
+
+	exports.names = {
+		// properties renamed to avoid clashes with reserved words
+		"class": "className",
+		"for": "htmlFor",
+		// properties written as camelCase
+		tabindex: "tabIndex",
+		readonly: "readOnly",
+		colspan: "colSpan",
+		frameborder: "frameBorder",
+		rowspan: "rowSpan",
+		valuetype: "valueType"
+	};
+
+	exports.get = function getProp(/*DOMNode|String*/ node, /*String*/ name){
+		// summary:
+		//		Gets a property on an HTML element.
+		// description:
+		//		Handles normalized getting of properties on DOM nodes.
+		//
+		// node: DOMNode|String
+		//		id or reference to the element to get the property on
+		// name: String
+		//		the name of the property to get.
+		// returns:
+		//		the value of the requested property or its default value
+		//
+		// example:
+		//	|	// get the current value of the "foo" property on a node
+		//	|	dojo.getProp(dojo.byId("nodeId"), "foo");
+		//	|	// or we can just pass the id:
+		//	|	dojo.getProp("nodeId", "foo");
+
+		node = dom.byId(node);
+		var lc = name.toLowerCase(), propName = exports.names[lc] || name;
+		return node[propName];	// Anything
+	};
+
+	exports.set = function setProp(/*DOMNode|String*/ node, /*String|Object*/ name, /*String?*/ value){
+		// summary:
+		//		Sets a property on an HTML element.
+		// description:
+		//		Handles normalized setting of properties on DOM nodes.
+		//
+		//		When passing functions as values, note that they will not be
+		//		directly assigned to slots on the node, but rather the default
+		//		behavior will be removed and the new behavior will be added
+		//		using `dojo.connect()`, meaning that event handler properties
+		//		will be normalized and that some caveats with regards to
+		//		non-standard behaviors for onsubmit apply. Namely that you
+		//		should cancel form submission using `dojo.stopEvent()` on the
+		//		passed event object instead of returning a boolean value from
+		//		the handler itself.
+		// node: DOMNode|String
+		//		id or reference to the element to set the property on
+		// name: String|Object
+		//		the name of the property to set, or a hash object to set
+		//		multiple properties at once.
+		// value: String?
+		//		The value to set for the property
+		// returns:
+		//		the DOM node
+		//
+		// example:
+		//	|	// use prop() to set the tab index
+		//	|	dojo.setProp("nodeId", "tabIndex", 3);
+		//	|
+		//
+		// example:
+		//	Set multiple values at once, including event handlers:
+		//	|	dojo.setProp("formId", {
+		//	|		"foo": "bar",
+		//	|		"tabIndex": -1,
+		//	|		"method": "POST",
+		//	|		"onsubmit": function(e){
+		//	|			// stop submitting the form. Note that the IE behavior
+		//	|			// of returning true or false will have no effect here
+		//	|			// since our handler is connect()ed to the built-in
+		//	|			// onsubmit behavior and so we need to use
+		//	|			// dojo.stopEvent() to ensure that the submission
+		//	|			// doesn't proceed.
+		//	|			dojo.stopEvent(e);
+		//	|
+		//	|			// submit the form with Ajax
+		//	|			dojo.xhrPost({ form: "formId" });
+		//	|		}
+		//	|	});
+		//
+		// example:
+		//	Style is s special case: Only set with an object hash of styles
+		//	|	dojo.setProp("someNode",{
+		//	|		id:"bar",
+		//	|		style:{
+		//	|			width:"200px", height:"100px", color:"#000"
+		//	|		}
+		//	|	});
+		//
+		// example:
+		//	Again, only set style as an object hash of styles:
+		//	|	var obj = { color:"#fff", backgroundColor:"#000" };
+		//	|	dojo.setProp("someNode", "style", obj);
+		//	|
+		//	|	// though shorter to use `dojo.style()` in this case:
+		//	|	dojo.style("someNode", obj);
+
+		node = dom.byId(node);
+		var l = arguments.length;
+		if(l == 2 && typeof name != "string"){ // inline'd type check
+			// the object form of setter: the 2nd argument is a dictionary
+			for(var x in name){
+				exports.set(node, x, name[x]);
+			}
+			return node; // DomNode
+		}
+		var lc = name.toLowerCase(), propName = exports.names[lc] || name;
+		if(propName == "style" && typeof value != "string"){ // inline'd type check
+			// special case: setting a style
+			style.set(node, value);
+			return node; // DomNode
+		}
+		if(propName == "innerHTML"){
+			// special case: assigning HTML
+			// the hash lists elements with read-only innerHTML on IE
+			if(has("ie") && node.tagName.toLowerCase() in {col: 1, colgroup: 1,
+						table: 1, tbody: 1, tfoot: 1, thead: 1, tr: 1, title: 1}){
+				ctr.empty(node);
+				node.appendChild(ctr.toDom(value, node.ownerDocument));
+			}else{
+				node[propName] = value;
+			}
+			return node; // DomNode
+		}
+		if(lang.isFunction(value)){
+			// special case: assigning an event handler
+			// clobber if we can
+			var attrId = node[_attrId];
+			if(!attrId){
+				attrId = _ctr++;
+				node[_attrId] = attrId;
+			}
+			if(!_evtHdlrMap[attrId]){
+				_evtHdlrMap[attrId] = {};
+			}
+			var h = _evtHdlrMap[attrId][propName];
+			if(h){
+				//h.remove();
+				conn.disconnect(h);
+			}else{
+				try{
+					delete node[propName];
+				}catch(e){}
+			}
+			// ensure that event objects are normalized, etc.
+			if(value){
+				//_evtHdlrMap[attrId][propName] = on(node, propName, value);
+				_evtHdlrMap[attrId][propName] = conn.connect(node, propName, value);
+			}else{
+				node[propName] = null;
+			}
+			return node; // DomNode
+		}
+		node[propName] = value;
+		return node;	// DomNode
+	};
+});

debian/missing-sources/dojo/dom-style.js

@@ -0,0 +1,312 @@
+define(["./sniff", "./dom"], function(has, dom){
+	// module:
+	//		dojo/dom-style
+
+	// =============================
+	// Style Functions
+	// =============================
+
+	// getComputedStyle drives most of the style code.
+	// Wherever possible, reuse the returned object.
+	//
+	// API functions below that need to access computed styles accept an
+	// optional computedStyle parameter.
+	// If this parameter is omitted, the functions will call getComputedStyle themselves.
+	// This way, calling code can access computedStyle once, and then pass the reference to
+	// multiple API functions.
+
+	// Although we normally eschew argument validation at this
+	// level, here we test argument 'node' for (duck)type,
+	// by testing nodeType, ecause 'document' is the 'parentNode' of 'body'
+	// it is frequently sent to this function even
+	// though it is not Element.
+	var getComputedStyle, style = {
+		// summary:
+		//		This module defines the core dojo DOM style API.
+	};
+	if(has("webkit")){
+		getComputedStyle = function(/*DomNode*/ node){
+			var s;
+			if(node.nodeType == 1){
+				var dv = node.ownerDocument.defaultView;
+				s = dv.getComputedStyle(node, null);
+				if(!s && node.style){
+					node.style.display = "";
+					s = dv.getComputedStyle(node, null);
+				}
+			}
+			return s || {};
+		};
+	}else if(has("ie") && (has("ie") < 9 || has("quirks"))){
+		getComputedStyle = function(node){
+			// IE (as of 7) doesn't expose Element like sane browsers
+			// currentStyle can be null on IE8!
+			return node.nodeType == 1 /* ELEMENT_NODE*/ && node.currentStyle ? node.currentStyle : {};
+		};
+	}else{
+		getComputedStyle = function(node){
+			return node.nodeType == 1 /* ELEMENT_NODE*/ ?
+				node.ownerDocument.defaultView.getComputedStyle(node, null) : {};
+		};
+	}
+	style.getComputedStyle = getComputedStyle;
+	/*=====
+	style.getComputedStyle = function(node){
+		// summary:
+		//		Returns a "computed style" object.
+		//
+		// description:
+		//		Gets a "computed style" object which can be used to gather
+		//		information about the current state of the rendered node.
+		//
+		//		Note that this may behave differently on different browsers.
+		//		Values may have different formats and value encodings across
+		//		browsers.
+		//
+		//		Note also that this method is expensive.  Wherever possible,
+		//		reuse the returned object.
+		//
+		//		Use the dojo.style() method for more consistent (pixelized)
+		//		return values.
+		//
+		// node: DOMNode
+		//		A reference to a DOM node. Does NOT support taking an
+		//		ID string for speed reasons.
+		// example:
+		//	|	dojo.getComputedStyle(dojo.byId('foo')).borderWidth;
+		//
+		// example:
+		//		Reusing the returned object, avoiding multiple lookups:
+		//	|	var cs = dojo.getComputedStyle(dojo.byId("someNode"));
+		//	|	var w = cs.width, h = cs.height;
+		return; // CSS2Properties
+	};
+	=====*/
+
+	var toPixel;
+	if(!has("ie")){
+		toPixel = function(element, value){
+			// style values can be floats, client code may want
+			// to round for integer pixels.
+			return parseFloat(value) || 0;
+		};
+	}else{
+		toPixel = function(element, avalue){
+			if(!avalue){ return 0; }
+			// on IE7, medium is usually 4 pixels
+			if(avalue == "medium"){ return 4; }
+			// style values can be floats, client code may
+			// want to round this value for integer pixels.
+			if(avalue.slice && avalue.slice(-2) == 'px'){ return parseFloat(avalue); }
+			var s = element.style, rs = element.runtimeStyle, cs = element.currentStyle,
+				sLeft = s.left, rsLeft = rs.left;
+			rs.left = cs.left;
+			try{
+				// 'avalue' may be incompatible with style.left, which can cause IE to throw
+				// this has been observed for border widths using "thin", "medium", "thick" constants
+				// those particular constants could be trapped by a lookup
+				// but perhaps there are more
+				s.left = avalue;
+				avalue = s.pixelLeft;
+			}catch(e){
+				avalue = 0;
+			}
+			s.left = sLeft;
+			rs.left = rsLeft;
+			return avalue;
+		};
+	}
+	style.toPixelValue = toPixel;
+	/*=====
+	style.toPixelValue = function(node, value){
+		// summary:
+		//		converts style value to pixels on IE or return a numeric value.
+		// node: DOMNode
+		// value: String
+		// returns: Number
+	};
+	=====*/
+
+	// FIXME: there opacity quirks on FF that we haven't ported over. Hrm.
+
+	var astr = "DXImageTransform.Microsoft.Alpha";
+	var af = function(n, f){
+		try{
+			return n.filters.item(astr);
+		}catch(e){
+			return f ? {} : null;
+		}
+	};
+
+	var _getOpacity =
+		has("ie") < 9 || (has("ie") < 10 && has("quirks")) ? function(node){
+			try{
+				return af(node).Opacity / 100; // Number
+			}catch(e){
+				return 1; // Number
+			}
+		} :
+		function(node){
+			return getComputedStyle(node).opacity;
+		};
+
+	var _setOpacity =
+		has("ie") < 9 || (has("ie") < 10 && has("quirks")) ? function(/*DomNode*/ node, /*Number*/ opacity){
+			if(opacity === ""){ opacity = 1; }
+			var ov = opacity * 100, fullyOpaque = opacity === 1;
+
+			// on IE7 Alpha(Filter opacity=100) makes text look fuzzy so disable it altogether (bug #2661),
+			// but still update the opacity value so we can get a correct reading if it is read later:
+			// af(node, 1).Enabled = !fullyOpaque;
+
+			if(fullyOpaque){
+				node.style.zoom = "";
+				if(af(node)){
+					node.style.filter = node.style.filter.replace(
+						new RegExp("\\s*progid:" + astr + "\\([^\\)]+?\\)", "i"), "");
+				}
+			}else{
+				node.style.zoom = 1;
+				if(af(node)){
+					af(node, 1).Opacity = ov;
+				}else{
+					node.style.filter += " progid:" + astr + "(Opacity=" + ov + ")";
+				}
+				af(node, 1).Enabled = true;
+			}
+
+			if(node.tagName.toLowerCase() == "tr"){
+				for(var td = node.firstChild; td; td = td.nextSibling){
+					if(td.tagName.toLowerCase() == "td"){
+						_setOpacity(td, opacity);
+					}
+				}
+			}
+			return opacity;
+		} :
+		function(node, opacity){
+			return node.style.opacity = opacity;
+		};
+
+	var _pixelNamesCache = {
+		left: true, top: true
+	};
+	var _pixelRegExp = /margin|padding|width|height|max|min|offset/; // |border
+	function _toStyleValue(node, type, value){
+		//TODO: should we really be doing string case conversion here? Should we cache it? Need to profile!
+		type = type.toLowerCase();
+		if(has("ie")){
+			if(value == "auto"){
+				if(type == "height"){ return node.offsetHeight; }
+				if(type == "width"){ return node.offsetWidth; }
+			}
+			if(type == "fontweight"){
+				switch(value){
+					case 700: return "bold";
+					case 400:
+					default: return "normal";
+				}
+			}
+		}
+		if(!(type in _pixelNamesCache)){
+			_pixelNamesCache[type] = _pixelRegExp.test(type);
+		}
+		return _pixelNamesCache[type] ? toPixel(node, value) : value;
+	}
+
+	var _floatAliases = {cssFloat: 1, styleFloat: 1, "float": 1};
+
+	// public API
+
+	style.get = function getStyle(/*DOMNode|String*/ node, /*String?*/ name){
+		// summary:
+		//		Accesses styles on a node.
+		// description:
+		//		Getting the style value uses the computed style for the node, so the value
+		//		will be a calculated value, not just the immediate node.style value.
+		//		Also when getting values, use specific style names,
+		//		like "borderBottomWidth" instead of "border" since compound values like
+		//		"border" are not necessarily reflected as expected.
+		//		If you want to get node dimensions, use `dojo.marginBox()`,
+		//		`dojo.contentBox()` or `dojo.position()`.
+		// node: DOMNode|String
+		//		id or reference to node to get style for
+		// name: String?
+		//		the style property to get
+		// example:
+		//		Passing only an ID or node returns the computed style object of
+		//		the node:
+		//	|	dojo.getStyle("thinger");
+		// example:
+		//		Passing a node and a style property returns the current
+		//		normalized, computed value for that property:
+		//	|	dojo.getStyle("thinger", "opacity"); // 1 by default
+
+		var n = dom.byId(node), l = arguments.length, op = (name == "opacity");
+		if(l == 2 && op){
+			return _getOpacity(n);
+		}
+		name = _floatAliases[name] ? "cssFloat" in n.style ? "cssFloat" : "styleFloat" : name;
+		var s = style.getComputedStyle(n);
+		return (l == 1) ? s : _toStyleValue(n, name, s[name] || n.style[name]); /* CSS2Properties||String||Number */
+	};
+
+	style.set = function setStyle(/*DOMNode|String*/ node, /*String|Object*/ name, /*String?*/ value){
+		// summary:
+		//		Sets styles on a node.
+		// node: DOMNode|String
+		//		id or reference to node to set style for
+		// name: String|Object
+		//		the style property to set in DOM-accessor format
+		//		("borderWidth", not "border-width") or an object with key/value
+		//		pairs suitable for setting each property.
+		// value: String?
+		//		If passed, sets value on the node for style, handling
+		//		cross-browser concerns.  When setting a pixel value,
+		//		be sure to include "px" in the value. For instance, top: "200px".
+		//		Otherwise, in some cases, some browsers will not apply the style.
+		//
+		// example:
+		//		Passing a node, a style property, and a value changes the
+		//		current display of the node and returns the new computed value
+		//	|	dojo.setStyle("thinger", "opacity", 0.5); // == 0.5
+		//
+		// example:
+		//		Passing a node, an object-style style property sets each of the values in turn and returns the computed style object of the node:
+		//	|	dojo.setStyle("thinger", {
+		//	|		"opacity": 0.5,
+		//	|		"border": "3px solid black",
+		//	|		"height": "300px"
+		//	|	});
+		//
+		// example:
+		//		When the CSS style property is hyphenated, the JavaScript property is camelCased.
+		//		font-size becomes fontSize, and so on.
+		//	|	dojo.setStyle("thinger",{
+		//	|		fontSize:"14pt",
+		//	|		letterSpacing:"1.2em"
+		//	|	});
+		//
+		// example:
+		//		dojo/NodeList implements .style() using the same syntax, omitting the "node" parameter, calling
+		//		dojo.style() on every element of the list. See: `dojo.query()` and `dojo/NodeList`
+		//	|	dojo.query(".someClassName").style("visibility","hidden");
+		//	|	// or
+		//	|	dojo.query("#baz > div").style({
+		//	|		opacity:0.75,
+		//	|		fontSize:"13pt"
+		//	|	});
+
+		var n = dom.byId(node), l = arguments.length, op = (name == "opacity");
+		name = _floatAliases[name] ? "cssFloat" in n.style ? "cssFloat" : "styleFloat" : name;
+		if(l == 3){
+			return op ? _setOpacity(n, value) : n.style[name] = value; // Number
+		}
+		for(var x in name){
+			style.set(node, x, name[x]);
+		}
+		return style.getComputedStyle(n);
+	};
+
+	return style;
+});

debian/missing-sources/dojo/dom.js

@@ -0,0 +1,185 @@
+define(["./sniff", "./_base/window"],
+		function(has, win){
+	// module:
+	//		dojo/dom
+
+	// FIXME: need to add unit tests for all the semi-public methods
+
+	if(has("ie") <= 7){
+		try{
+			document.execCommand("BackgroundImageCache", false, true);
+		}catch(e){
+			// sane browsers don't have cache "issues"
+		}
+	}
+
+	// =============================
+	// DOM Functions
+	// =============================
+
+	// the result object
+	var dom = {
+		// summary:
+		//		This module defines the core dojo DOM API.
+	};
+
+	if(has("ie")){
+		dom.byId = function(id, doc){
+			if(typeof id != "string"){
+				return id;
+			}
+			var _d = doc || win.doc, te = id && _d.getElementById(id);
+			// attributes.id.value is better than just id in case the
+			// user has a name=id inside a form
+			if(te && (te.attributes.id.value == id || te.id == id)){
+				return te;
+			}else{
+				var eles = _d.all[id];
+				if(!eles || eles.nodeName){
+					eles = [eles];
+				}
+				// if more than 1, choose first with the correct id
+				var i = 0;
+				while((te = eles[i++])){
+					if((te.attributes && te.attributes.id && te.attributes.id.value == id) || te.id == id){
+						return te;
+					}
+				}
+			}
+		};
+	}else{
+		dom.byId = function(id, doc){
+			// inline'd type check.
+			// be sure to return null per documentation, to match IE branch.
+			return ((typeof id == "string") ? (doc || win.doc).getElementById(id) : id) || null; // DOMNode
+		};
+	}
+	/*=====
+	 dom.byId = function(id, doc){
+		 // summary:
+		 //		Returns DOM node with matching `id` attribute or falsy value (ex: null or undefined)
+		 //		if not found.  If `id` is a DomNode, this function is a no-op.
+		 //
+		 // id: String|DOMNode
+		 //		A string to match an HTML id attribute or a reference to a DOM Node
+		 //
+		 // doc: Document?
+		 //		Document to work in. Defaults to the current value of
+		 //		dojo.doc.  Can be used to retrieve
+		 //		node references from other documents.
+		 //
+		 // example:
+		 //		Look up a node by ID:
+		 //	|	var n = dojo.byId("foo");
+		 //
+		 // example:
+		 //		Check if a node exists, and use it.
+		 //	|	var n = dojo.byId("bar");
+		 //	|	if(n){ doStuff() ... }
+		 //
+		 // example:
+		 //		Allow string or DomNode references to be passed to a custom function:
+		 //	|	var foo = function(nodeOrId){
+		 //	|		nodeOrId = dojo.byId(nodeOrId);
+		 //	|		// ... more stuff
+		 //	|	}
+	 };
+	 =====*/
+
+	dom.isDescendant = function(/*DOMNode|String*/ node, /*DOMNode|String*/ ancestor){
+		// summary:
+		//		Returns true if node is a descendant of ancestor
+		// node: DOMNode|String
+		//		string id or node reference to test
+		// ancestor: DOMNode|String
+		//		string id or node reference of potential parent to test against
+		//
+		// example:
+		//		Test is node id="bar" is a descendant of node id="foo"
+		//	|	if(dojo.isDescendant("bar", "foo")){ ... }
+
+		try{
+			node = dom.byId(node);
+			ancestor = dom.byId(ancestor);
+			while(node){
+				if(node == ancestor){
+					return true; // Boolean
+				}
+				node = node.parentNode;
+			}
+		}catch(e){ /* squelch, return false */ }
+		return false; // Boolean
+	};
+
+
+	// TODO: do we need setSelectable in the base?
+
+	// Add feature test for user-select CSS property
+	// (currently known to work in all but IE < 10 and Opera)
+	has.add("css-user-select", function(global, doc, element){
+		// Avoid exception when dom.js is loaded in non-browser environments
+		if(!element){ return false; }
+		
+		var style = element.style;
+		var prefixes = ["Khtml", "O", "ms", "Moz", "Webkit"],
+			i = prefixes.length,
+			name = "userSelect",
+			prefix;
+
+		// Iterate prefixes from most to least likely
+		do{
+			if(typeof style[name] !== "undefined"){
+				// Supported; return property name
+				return name;
+			}
+		}while(i-- && (name = prefixes[i] + "UserSelect"));
+
+		// Not supported if we didn't return before now
+		return false;
+	});
+
+	/*=====
+	dom.setSelectable = function(node, selectable){
+		// summary:
+		//		Enable or disable selection on a node
+		// node: DOMNode|String
+		//		id or reference to node
+		// selectable: Boolean
+		//		state to put the node in. false indicates unselectable, true
+		//		allows selection.
+		// example:
+		//		Make the node id="bar" unselectable
+		//	|	dojo.setSelectable("bar");
+		// example:
+		//		Make the node id="bar" selectable
+		//	|	dojo.setSelectable("bar", true);
+	};
+	=====*/
+
+	var cssUserSelect = has("css-user-select");
+	dom.setSelectable = cssUserSelect ? function(node, selectable){
+		// css-user-select returns a (possibly vendor-prefixed) CSS property name
+		dom.byId(node).style[cssUserSelect] = selectable ? "" : "none";
+	} : function(node, selectable){
+		node = dom.byId(node);
+
+		// (IE < 10 / Opera) Fall back to setting/removing the
+		// unselectable attribute on the element and all its children
+		var nodes = node.getElementsByTagName("*"),
+			i = nodes.length;
+
+		if(selectable){
+			node.removeAttribute("unselectable");
+			while(i--){
+				nodes[i].removeAttribute("unselectable");
+			}
+		}else{
+			node.setAttribute("unselectable", "on");
+			while(i--){
+				nodes[i].setAttribute("unselectable", "on");
+			}
+		}
+	};
+
+	return dom;
+});

debian/missing-sources/dojo/domReady.js

@@ -0,0 +1,124 @@
+define(['./has'], function(has){
+	var global = this,
+		doc = document,
+		readyStates = { 'loaded': 1, 'complete': 1 },
+		fixReadyState = typeof doc.readyState != "string",
+		ready = !!readyStates[doc.readyState],
+		readyQ = [],
+		recursiveGuard;
+
+	function domReady(callback){
+		// summary:
+		//		Plugin to delay require()/define() callback from firing until the DOM has finished loading.
+		readyQ.push(callback);
+		if(ready){ processQ(); }
+	}
+	domReady.load = function(id, req, load){
+		domReady(load);
+	};
+
+	// Export queue so that ready() can check if it's empty or not.
+	domReady._Q = readyQ;
+	domReady._onQEmpty = function(){
+		// summary:
+		//		Private method overridden by dojo/ready, to notify when everything in the
+		//		domReady queue has been processed.  Do not use directly.
+		//		Will be removed in 2.0, along with domReady._Q.
+	};
+
+	// For FF <= 3.5
+	if(fixReadyState){ doc.readyState = "loading"; }
+
+	function processQ(){
+		// Calls all functions in the queue in order, unless processQ() is already running, in which case just return
+
+		if(recursiveGuard){ return; }
+		recursiveGuard = true;
+
+		while(readyQ.length){
+			try{
+				(readyQ.shift())(doc);
+			}catch(err){
+				console.log("Error on domReady callback: " + err);
+			}
+		}
+
+		recursiveGuard = false;
+
+		// Notification for dojo/ready.  Remove for 2.0.
+		// Note that this could add more tasks to the ready queue.
+		domReady._onQEmpty();
+	}
+
+	if(!ready){
+		var tests = [],
+			detectReady = function(evt){
+				evt = evt || global.event;
+				if(ready || (evt.type == "readystatechange" && !readyStates[doc.readyState])){ return; }
+
+				// For FF <= 3.5
+				if(fixReadyState){ doc.readyState = "complete"; }
+
+				ready = 1;
+				processQ();
+			},
+			on = function(node, event){
+				node.addEventListener(event, detectReady, false);
+				readyQ.push(function(){ node.removeEventListener(event, detectReady, false); });
+			};
+
+		if(!has("dom-addeventlistener")){
+			on = function(node, event){
+				event = "on" + event;
+				node.attachEvent(event, detectReady);
+				readyQ.push(function(){ node.detachEvent(event, detectReady); });
+			};
+
+			var div = doc.createElement("div");
+			try{
+				if(div.doScroll && global.frameElement === null){
+					// the doScroll test is only useful if we're in the top-most frame
+					tests.push(function(){
+						// Derived with permission from Diego Perini's IEContentLoaded
+						// http://javascript.nwbox.com/IEContentLoaded/
+						try{
+							div.doScroll("left");
+							return 1;
+						}catch(e){}
+					});
+				}
+			}catch(e){}
+		}
+
+		on(doc, "DOMContentLoaded");
+		on(global, "load");
+
+		if("onreadystatechange" in doc){
+			on(doc, "readystatechange");
+		}else if(!fixReadyState){
+			// if the ready state property exists and there's
+			// no readystatechange event, poll for the state
+			// to change
+			tests.push(function(){
+				return readyStates[doc.readyState];
+			});
+		}
+
+		if(tests.length){
+			var poller = function(){
+				if(ready){ return; }
+				var i = tests.length;
+				while(i--){
+					if(tests[i]()){
+						detectReady("poller");
+						return;
+					}
+				}
+				setTimeout(poller, 30);
+			};
+			poller();
+		}
+	}
+
+	return domReady;
+});

debian/missing-sources/dojo/errors/CancelError.js

@@ -0,0 +1,13 @@
+define(["./create"], function(create){
+	// module:
+	//		dojo/errors/CancelError
+
+	/*=====
+	return function(){
+		// summary:
+		//		Default error if a promise is canceled without a reason.
+	};
+	=====*/
+
+	return create("CancelError", null, null, { dojoType: "cancel" });
+});

debian/missing-sources/dojo/errors/create.js

@@ -0,0 +1,41 @@
+define(["../_base/lang"], function(lang){
+	return function(name, ctor, base, props){
+		base = base || Error;
+
+		var ErrorCtor = function(message){
+			if(base === Error){
+				if(Error.captureStackTrace){
+					Error.captureStackTrace(this, ErrorCtor);
+				}
+
+				// Error.call() operates on the returned error
+				// object rather than operating on |this|
+				var err = Error.call(this, message),
+					prop;
+
+				// Copy own properties from err to |this|
+				for(prop in err){
+					if(err.hasOwnProperty(prop)){
+						this[prop] = err[prop];
+					}
+				}
+
+				// messsage is non-enumerable in ES5
+				this.message = message;
+				// stack is non-enumerable in at least Firefox
+				this.stack = err.stack;
+			}else{
+				base.apply(this, arguments);
+			}
+			if(ctor){
+				ctor.apply(this, arguments);
+			}
+		};
+
+		ErrorCtor.prototype = lang.delegate(base.prototype, props);
+		ErrorCtor.prototype.name = name;
+		ErrorCtor.prototype.constructor = ErrorCtor;
+
+		return ErrorCtor;
+	};
+});

debian/missing-sources/dojo/has.js

@@ -0,0 +1,173 @@
+define(["require", "module"], function(require, module){
+	// module:
+	//		dojo/has
+	// summary:
+	//		Defines the has.js API and several feature tests used by dojo.
+	// description:
+	//		This module defines the has API as described by the project has.js with the following additional features:
+	//
+	//		- the has test cache is exposed at has.cache.
+	//		- the method has.add includes a forth parameter that controls whether or not existing tests are replaced
+	//		- the loader's has cache may be optionally copied into this module's has cahce.
+	//
+	//		This module adopted from https://github.com/phiggins42/has.js; thanks has.js team!
+
+	// try to pull the has implementation from the loader; both the dojo loader and bdLoad provide one
+	// if using a foreign loader, then the has cache may be initialized via the config object for this module
+	// WARNING: if a foreign loader defines require.has to be something other than the has.js API, then this implementation fail
+	var has = require.has || function(){};
+	if(!has("dojo-has-api")){
+		var
+			isBrowser =
+				// the most fundamental decision: are we in the browser?
+				typeof window != "undefined" &&
+				typeof location != "undefined" &&
+				typeof document != "undefined" &&
+				window.location == location && window.document == document,
+
+			// has API variables
+			global = this,
+			doc = isBrowser && document,
+			element = doc && doc.createElement("DiV"),
+			cache = (module.config && module.config()) || {};
+
+		has = function(name){
+			// summary:
+			//		Return the current value of the named feature.
+			//
+			// name: String|Integer
+			//		The name (if a string) or identifier (if an integer) of the feature to test.
+			//
+			// description:
+			//		Returns the value of the feature named by name. The feature must have been
+			//		previously added to the cache by has.add.
+
+			return typeof cache[name] == "function" ? (cache[name] = cache[name](global, doc, element)) : cache[name]; // Boolean
+		};
+
+		has.cache = cache;
+
+		has.add = function(name, test, now, force){
+			// summary:
+			//	 	Register a new feature test for some named feature.
+			// name: String|Integer
+			//	 	The name (if a string) or identifier (if an integer) of the feature to test.
+			// test: Function
+			//		 A test function to register. If a function, queued for testing until actually
+			//		 needed. The test function should return a boolean indicating
+			//	 	the presence of a feature or bug.
+			// now: Boolean?
+			//		 Optional. Omit if `test` is not a function. Provides a way to immediately
+			//		 run the test and cache the result.
+			// force: Boolean?
+			//	 	Optional. If the test already exists and force is truthy, then the existing
+			//	 	test will be replaced; otherwise, add does not replace an existing test (that
+			//	 	is, by default, the first test advice wins).
+			// example:
+			//		A redundant test, testFn with immediate execution:
+			//	|	has.add("javascript", function(){ return true; }, true);
+			//
+			// example:
+			//		Again with the redundantness. You can do this in your tests, but we should
+			//		not be doing this in any internal has.js tests
+			//	|	has.add("javascript", true);
+			//
+			// example:
+			//		Three things are passed to the testFunction. `global`, `document`, and a generic element
+			//		from which to work your test should the need arise.
+			//	|	has.add("bug-byid", function(g, d, el){
+			//	|		// g	== global, typically window, yadda yadda
+			//	|		// d	== document object
+			//	|		// el == the generic element. a `has` element.
+			//	|		return false; // fake test, byid-when-form-has-name-matching-an-id is slightly longer
+			//	|	});
+
+			(typeof cache[name]=="undefined" || force) && (cache[name]= test);
+			return now && has(name);
+		};
+
+		// since we're operating under a loader that doesn't provide a has API, we must explicitly initialize
+		// has as it would have otherwise been initialized by the dojo loader; use has.add to the builder
+		// can optimize these away iff desired
+		has.add("host-browser", isBrowser);
+		has.add("dom", isBrowser);
+		has.add("dojo-dom-ready-api", 1);
+		has.add("dojo-sniff", 1);
+	}
+
+	if(has("host-browser")){
+		// Common application level tests
+		has.add("dom-addeventlistener", !!document.addEventListener);
+		has.add("touch", "ontouchstart" in document || window.navigator.msMaxTouchPoints > 0);
+		// I don't know if any of these tests are really correct, just a rough guess
+		has.add("device-width", screen.availWidth || innerWidth);
+
+		// Tests for DOMNode.attributes[] behavior:
+		//	 - dom-attributes-explicit - attributes[] only lists explicitly user specified attributes
+		//	 - dom-attributes-specified-flag (IE8) - need to check attr.specified flag to skip attributes user didn't specify
+		//	 - Otherwise, in IE6-7. attributes[] will list hundreds of values, so need to do outerHTML to get attrs instead.
+		var form = document.createElement("form");
+		has.add("dom-attributes-explicit", form.attributes.length == 0); // W3C
+		has.add("dom-attributes-specified-flag", form.attributes.length > 0 && form.attributes.length < 40);	// IE8
+	}
+
+	has.clearElement = function(element){
+		// summary:
+		//	 Deletes the contents of the element passed to test functions.
+		element.innerHTML= "";
+		return element;
+	};
+
+	has.normalize = function(id, toAbsMid){
+		// summary:
+		//	 Resolves id into a module id based on possibly-nested tenary expression that branches on has feature test value(s).
+		//
+		// toAbsMid: Function
+		//	 Resolves a relative module id into an absolute module id
+		var
+			tokens = id.match(/[\?:]|[^:\?]*/g), i = 0,
+			get = function(skip){
+				var term = tokens[i++];
+				if(term == ":"){
+					// empty string module name, resolves to 0
+					return 0;
+				}else{
+					// postfixed with a ? means it is a feature to branch on, the term is the name of the feature
+					if(tokens[i++] == "?"){
+						if(!skip && has(term)){
+							// matched the feature, get the first value from the options
+							return get();
+						}else{
+							// did not match, get the second value, passing over the first
+							get(true);
+							return get(skip);
+						}
+					}
+					// a module
+					return term || 0;
+				}
+			};
+		id = get();
+		return id && toAbsMid(id);
+	};
+
+	has.load = function(id, parentRequire, loaded){
+		// summary:
+		//		Conditional loading of AMD modules based on a has feature test value.
+		// id: String
+		//		Gives the resolved module id to load.
+		// parentRequire: Function
+		//		The loader require function with respect to the module that contained the plugin resource in it's
+		//		dependency list.
+		// loaded: Function
+		//	 Callback to loader that consumes result of plugin demand.
+
+		if(id){
+			parentRequire([id], loaded);
+		}else{
+			loaded();
+		}
+	};
+
+	return has;
+});

debian/missing-sources/dojo/hash.js

@@ -0,0 +1,256 @@
+define(["./_base/kernel", "require", "./_base/config", "./aspect", "./_base/lang", "./topic", "./domReady", "./sniff"],
+	function(dojo, require, config, aspect, lang, topic, domReady, has){
+
+	// module:
+	//		dojo/hash
+
+	dojo.hash = function(/* String? */ hash, /* Boolean? */ replace){
+		// summary:
+		//		Gets or sets the hash string in the browser URL.
+		// description:
+		//		Handles getting and setting of location.hash.
+		//
+		//		 - If no arguments are passed, acts as a getter.
+		//		 - If a string is passed, acts as a setter.
+		// hash:
+		//		the hash is set - #string.
+		// replace:
+		//		If true, updates the hash value in the current history
+		//		state instead of creating a new history state.
+		// returns:
+		//		when used as a getter, returns the current hash string.
+		//		when used as a setter, returns the new hash string.
+		// example:
+		//	|	topic.subscribe("/dojo/hashchange", context, callback);
+		//	|
+		//	|	function callback (hashValue){
+		//	|		// do something based on the hash value.
+		//	|	}
+
+		// getter
+		if(!arguments.length){
+			return _getHash();
+		}
+		// setter
+		if(hash.charAt(0) == "#"){
+			hash = hash.substring(1);
+		}
+		if(replace){
+			_replace(hash);
+		}else{
+			location.href = "#" + hash;
+		}
+		return hash; // String
+	};
+
+	// Global vars
+	var _recentHash, _ieUriMonitor, _connect,
+		_pollFrequency = config.hashPollFrequency || 100;
+
+	//Internal functions
+	function _getSegment(str, delimiter){
+		var i = str.indexOf(delimiter);
+		return (i >= 0) ? str.substring(i+1) : "";
+	}
+
+	function _getHash(){
+		return _getSegment(location.href, "#");
+	}
+
+	function _dispatchEvent(){
+		topic.publish("/dojo/hashchange", _getHash());
+	}
+
+	function _pollLocation(){
+		if(_getHash() === _recentHash){
+			return;
+		}
+		_recentHash = _getHash();
+		_dispatchEvent();
+	}
+
+	function _replace(hash){
+		if(_ieUriMonitor){
+			if(_ieUriMonitor.isTransitioning()){
+				setTimeout(lang.hitch(null,_replace,hash), _pollFrequency);
+				return;
+			}
+			var href = _ieUriMonitor.iframe.location.href;
+			var index = href.indexOf('?');
+			// main frame will detect and update itself
+			_ieUriMonitor.iframe.location.replace(href.substring(0, index) + "?" + hash);
+			return;
+		}
+		location.replace("#"+hash);
+		!_connect && _pollLocation();
+	}
+
+	function IEUriMonitor(){
+		// summary:
+		//		Determine if the browser's URI has changed or if the user has pressed the
+		//		back or forward button. If so, call _dispatchEvent.
+		//
+		// description:
+		//		IE doesn't add changes to the URI's hash into the history unless the hash
+		//		value corresponds to an actual named anchor in the document. To get around
+		//		this IE difference, we use a background IFrame to maintain a back-forward
+		//		history, by updating the IFrame's query string to correspond to the
+		//		value of the main browser location's hash value.
+		//
+		//		E.g. if the value of the browser window's location changes to
+		//
+		//		#action=someAction
+		//
+		//		... then we'd update the IFrame's source to:
+		//
+		//		?action=someAction
+		//
+		//		This design leads to a somewhat complex state machine, which is
+		//		described below:
+		//
+		//		####s1
+		//
+		//		Stable state - neither the window's location has changed nor
+		//		has the IFrame's location. Note that this is the 99.9% case, so
+		//		we optimize for it.
+		//
+		//		Transitions: s1, s2, s3
+		//
+		//		####s2
+		//
+		//		Window's location changed - when a user clicks a hyperlink or
+		//		code programmatically changes the window's URI.
+		//
+		//		Transitions: s4
+		//
+		//		####s3
+		//
+		//		Iframe's location changed as a result of user pressing back or
+		//		forward - when the user presses back or forward, the location of
+		//		the background's iframe changes to the previous or next value in
+		//		its history.
+		//
+		//		Transitions: s1
+		//
+		//		####s4
+		//
+		//		IEUriMonitor has programmatically changed the location of the
+		//		background iframe, but it's location hasn't yet changed. In this
+		//		case we do nothing because we need to wait for the iframe's
+		//		location to reflect its actual state.
+		//
+		//		Transitions: s4, s5
+		//
+		//		####s5
+		//
+		//		IEUriMonitor has programmatically changed the location of the
+		//		background iframe, and the iframe's location has caught up with
+		//		reality. In this case we need to transition to s1.
+		//
+		//		Transitions: s1
+		//
+		//		The hashchange event is always dispatched on the transition back to s1.
+
+
+		// create and append iframe
+		var ifr = document.createElement("iframe"),
+			IFRAME_ID = "dojo-hash-iframe",
+			ifrSrc = config.dojoBlankHtmlUrl || require.toUrl("./resources/blank.html");
+
+		if(config.useXDomain && !config.dojoBlankHtmlUrl){
+			console.warn("dojo.hash: When using cross-domain Dojo builds,"
+				+ " please save dojo/resources/blank.html to your domain and set djConfig.dojoBlankHtmlUrl"
+				+ " to the path on your domain to blank.html");
+		}
+
+		ifr.id = IFRAME_ID;
+		ifr.src = ifrSrc + "?" + _getHash();
+		ifr.style.display = "none";
+		document.body.appendChild(ifr);
+
+		this.iframe = dojo.global[IFRAME_ID];
+		var recentIframeQuery, transitioning, expectedIFrameQuery, docTitle, ifrOffline,
+			iframeLoc = this.iframe.location;
+
+		function resetState(){
+			_recentHash = _getHash();
+			recentIframeQuery = ifrOffline ? _recentHash : _getSegment(iframeLoc.href, "?");
+			transitioning = false;
+			expectedIFrameQuery = null;
+		}
+
+		this.isTransitioning = function(){
+			return transitioning;
+		};
+
+		this.pollLocation = function(){
+			if(!ifrOffline){
+				try{
+					//see if we can access the iframe's location without a permission denied error
+					var iframeSearch = _getSegment(iframeLoc.href, "?");
+					//good, the iframe is same origin (no thrown exception)
+					if(document.title != docTitle){ //sync title of main window with title of iframe.
+						docTitle = this.iframe.document.title = document.title;
+					}
+				}catch(e){
+					//permission denied - server cannot be reached.
+					ifrOffline = true;
+					console.error("dojo.hash: Error adding history entry. Server unreachable.");
+				}
+			}
+			var hash = _getHash();
+			if(transitioning && _recentHash === hash){
+				// we're in an iframe transition (s4 or s5)
+				if(ifrOffline || iframeSearch === expectedIFrameQuery){
+					// s5 (iframe caught up to main window or iframe offline), transition back to s1
+					resetState();
+					_dispatchEvent();
+				}else{
+					// s4 (waiting for iframe to catch up to main window)
+					setTimeout(lang.hitch(this,this.pollLocation),0);
+					return;
+				}
+			}else if(_recentHash === hash && (ifrOffline || recentIframeQuery === iframeSearch)){
+				// we're in stable state (s1, iframe query == main window hash), do nothing
+			}else{
+				// the user has initiated a URL change somehow.
+				// sync iframe query <-> main window hash
+				if(_recentHash !== hash){
+					// s2 (main window location changed), set iframe url and transition to s4
+					_recentHash = hash;
+					transitioning = true;
+					expectedIFrameQuery = hash;
+					ifr.src = ifrSrc + "?" + expectedIFrameQuery;
+					ifrOffline = false; //we're updating the iframe src - set offline to false so we can check again on next poll.
+					setTimeout(lang.hitch(this,this.pollLocation),0); //yielded transition to s4 while iframe reloads.
+					return;
+				}else if(!ifrOffline){
+					// s3 (iframe location changed via back/forward button), set main window url and transition to s1.
+					location.href = "#" + iframeLoc.search.substring(1);
+					resetState();
+					_dispatchEvent();
+				}
+			}
+			setTimeout(lang.hitch(this,this.pollLocation), _pollFrequency);
+		};
+		resetState(); // initialize state (transition to s1)
+		setTimeout(lang.hitch(this,this.pollLocation), _pollFrequency);
+	}
+	domReady(function(){
+		if("onhashchange" in dojo.global && (!has("ie") || (has("ie") >= 8 && document.compatMode != "BackCompat"))){	//need this IE browser test because "onhashchange" exists in IE8 in IE7 mode
+			_connect = aspect.after(dojo.global,"onhashchange",_dispatchEvent, true);
+		}else{
+			if(document.addEventListener){ // Non-IE
+				_recentHash = _getHash();
+				setInterval(_pollLocation, _pollFrequency); //Poll the window location for changes
+			}else if(document.attachEvent){ // IE7-
+				//Use hidden iframe in versions of IE that don't have onhashchange event
+				_ieUriMonitor = new IEUriMonitor();
+			}
+			// else non-supported browser, do nothing.
+		}
+	});
+
+	return dojo.hash;
+
+});

debian/missing-sources/dojo/io-query.js

@@ -0,0 +1,97 @@
+define(["./_base/lang"], function(lang){
+
+// module:
+//		dojo/io-query
+
+var backstop = {};
+
+return {
+// summary:
+//		This module defines query string processing functions.
+
+	objectToQuery: function objectToQuery(/*Object*/ map){
+		// summary:
+        //		takes a name/value mapping object and returns a string representing
+        //		a URL-encoded version of that object.
+        // example:
+        //		this object:
+        //
+        //	|	{
+        //	|		blah: "blah",
+        //	|		multi: [
+        //	|			"thud",
+        //	|			"thonk"
+        //	|		]
+        //	|	};
+        //
+        //		yields the following query string:
+        //
+        //	|	"blah=blah&multi=thud&multi=thonk"
+
+        // FIXME: need to implement encodeAscii!!
+        var enc = encodeURIComponent, pairs = [];
+        for(var name in map){
+            var value = map[name];
+            if(value != backstop[name]){
+                var assign = enc(name) + "=";
+                if(lang.isArray(value)){
+                    for(var i = 0, l = value.length; i < l; ++i){
+                        pairs.push(assign + enc(value[i]));
+                    }
+                }else{
+                    pairs.push(assign + enc(value));
+                }
+            }
+        }
+        return pairs.join("&"); // String
+    },
+
+	queryToObject: function queryToObject(/*String*/ str){
+        // summary:
+        //		Create an object representing a de-serialized query section of a
+        //		URL. Query keys with multiple values are returned in an array.
+        //
+        // example:
+        //		This string:
+        //
+        //	|		"foo=bar&foo=baz&thinger=%20spaces%20=blah&zonk=blarg&"
+        //
+        //		results in this object structure:
+        //
+        //	|		{
+        //	|			foo: [ "bar", "baz" ],
+        //	|			thinger: " spaces =blah",
+        //	|			zonk: "blarg"
+        //	|		}
+        //
+        //		Note that spaces and other urlencoded entities are correctly
+        //		handled.
+
+        // FIXME: should we grab the URL string if we're not passed one?
+        var dec = decodeURIComponent, qp = str.split("&"), ret = {}, name, val;
+        for(var i = 0, l = qp.length, item; i < l; ++i){
+            item = qp[i];
+            if(item.length){
+                var s = item.indexOf("=");
+                if(s < 0){
+                    name = dec(item);
+                    val = "";
+                }else{
+                    name = dec(item.slice(0, s));
+                    val  = dec(item.slice(s + 1));
+                }
+                if(typeof ret[name] == "string"){ // inline'd type check
+                    ret[name] = [ret[name]];
+                }
+
+                if(lang.isArray(ret[name])){
+                    ret[name].push(val);
+                }else{
+                    ret[name] = val;
+                }
+            }
+        }
+        return ret; // Object
+    }
+};
+});

debian/missing-sources/dojo/keys.js

@@ -0,0 +1,77 @@
+define(["./_base/kernel", "./sniff"], function(dojo, has){
+
+	// module:
+	//		dojo/keys
+
+	return dojo.keys = {
+		// summary:
+		//		Definitions for common key values.  Client code should test keyCode against these named constants,
+		//		as the actual codes can vary by browser.
+
+		BACKSPACE: 8,
+		TAB: 9,
+		CLEAR: 12,
+		ENTER: 13,
+		SHIFT: 16,
+		CTRL: 17,
+		ALT: 18,
+		META: has("webkit") ? 91 : 224,		// the apple key on macs
+		PAUSE: 19,
+		CAPS_LOCK: 20,
+		ESCAPE: 27,
+		SPACE: 32,
+		PAGE_UP: 33,
+		PAGE_DOWN: 34,
+		END: 35,
+		HOME: 36,
+		LEFT_ARROW: 37,
+		UP_ARROW: 38,
+		RIGHT_ARROW: 39,
+		DOWN_ARROW: 40,
+		INSERT: 45,
+		DELETE: 46,
+		HELP: 47,
+		LEFT_WINDOW: 91,
+		RIGHT_WINDOW: 92,
+		SELECT: 93,
+		NUMPAD_0: 96,
+		NUMPAD_1: 97,
+		NUMPAD_2: 98,
+		NUMPAD_3: 99,
+		NUMPAD_4: 100,
+		NUMPAD_5: 101,
+		NUMPAD_6: 102,
+		NUMPAD_7: 103,
+		NUMPAD_8: 104,
+		NUMPAD_9: 105,
+		NUMPAD_MULTIPLY: 106,
+		NUMPAD_PLUS: 107,
+		NUMPAD_ENTER: 108,
+		NUMPAD_MINUS: 109,
+		NUMPAD_PERIOD: 110,
+		NUMPAD_DIVIDE: 111,
+		F1: 112,
+		F2: 113,
+		F3: 114,
+		F4: 115,
+		F5: 116,
+		F6: 117,
+		F7: 118,
+		F8: 119,
+		F9: 120,
+		F10: 121,
+		F11: 122,
+		F12: 123,
+		F13: 124,
+		F14: 125,
+		F15: 126,
+		NUM_LOCK: 144,
+		SCROLL_LOCK: 145,
+		UP_DPAD: 175,
+		DOWN_DPAD: 176,
+		LEFT_DPAD: 177,
+		RIGHT_DPAD: 178,
+		// virtual key mapping
+		copyKey: has("mac") && !has("air") ? (has("safari") ? 91 : 224 ) : 17
+	};
+});

debian/missing-sources/dojo/mouse.js

@@ -0,0 +1,171 @@
+define(["./_base/kernel", "./on", "./has", "./dom", "./_base/window"], function(dojo, on, has, dom, win){
+
+	// module:
+	//		dojo/mouse
+
+    has.add("dom-quirks", win.doc && win.doc.compatMode == "BackCompat");
+	has.add("events-mouseenter", win.doc && "onmouseenter" in win.doc.createElement("div"));
+	has.add("events-mousewheel", win.doc && 'onmousewheel' in win.doc);
+
+	var mouseButtons;
+	if((has("dom-quirks") && has("ie")) || !has("dom-addeventlistener")){
+		mouseButtons = {
+			LEFT:   1,
+			MIDDLE: 4,
+			RIGHT:  2,
+			// helper functions
+			isButton: function(e, button){ return e.button & button; },
+			isLeft:   function(e){ return e.button & 1; },
+			isMiddle: function(e){ return e.button & 4; },
+			isRight:  function(e){ return e.button & 2; }
+		};
+	}else{
+		mouseButtons = {
+			LEFT:   0,
+			MIDDLE: 1,
+			RIGHT:  2,
+			// helper functions
+			isButton: function(e, button){ return e.button == button; },
+			isLeft:   function(e){ return e.button == 0; },
+			isMiddle: function(e){ return e.button == 1; },
+			isRight:  function(e){ return e.button == 2; }
+		};
+	}
+	dojo.mouseButtons = mouseButtons;
+
+/*=====
+	dojo.mouseButtons = {
+		// LEFT: Number
+		//		Numeric value of the left mouse button for the platform.
+		LEFT:   0,
+		// MIDDLE: Number
+		//		Numeric value of the middle mouse button for the platform.
+		MIDDLE: 1,
+		// RIGHT: Number
+		//		Numeric value of the right mouse button for the platform.
+		RIGHT:  2,
+
+		isButton: function(e, button){
+			// summary:
+			//		Checks an event object for a pressed button
+			// e: Event
+			//		Event object to examine
+			// button: Number
+			//		The button value (example: dojo.mouseButton.LEFT)
+			return e.button == button; // Boolean
+		},
+		isLeft: function(e){
+			// summary:
+			//		Checks an event object for the pressed left button
+			// e: Event
+			//		Event object to examine
+			return e.button == 0; // Boolean
+		},
+		isMiddle: function(e){
+			// summary:
+			//		Checks an event object for the pressed middle button
+			// e: Event
+			//		Event object to examine
+			return e.button == 1; // Boolean
+		},
+		isRight: function(e){
+			// summary:
+			//		Checks an event object for the pressed right button
+			// e: Event
+			//		Event object to examine
+			return e.button == 2; // Boolean
+		}
+	};
+=====*/
+
+	function eventHandler(type, selectHandler){
+		// emulation of mouseenter/leave with mouseover/out using descendant checking
+		var handler = function(node, listener){
+			return on(node, type, function(evt){
+				if(selectHandler){
+					return selectHandler(evt, listener);
+				}
+				if(!dom.isDescendant(evt.relatedTarget, node)){
+					return listener.call(this, evt);
+				}
+			});
+		};
+		handler.bubble = function(select){
+			return eventHandler(type, function(evt, listener){
+				// using a selector, use the select function to determine if the mouse moved inside the selector and was previously outside the selector
+				var target = select(evt.target);
+				var relatedTarget = evt.relatedTarget;
+				if(target && (target != (relatedTarget && relatedTarget.nodeType == 1 && select(relatedTarget)))){
+					return listener.call(target, evt);
+				} 
+			});
+		};
+		return handler;
+	}
+	var wheel;
+	if(has("events-mousewheel")){
+		wheel = 'mousewheel';
+	}else{ //firefox
+		wheel = function(node, listener){
+			return on(node, 'DOMMouseScroll', function(evt){
+				evt.wheelDelta = -evt.detail;
+				listener.call(this, evt);
+			});
+		};
+	}
+	return {
+		// summary:
+		//		This module provide mouse event handling utility functions and exports
+		//		mouseenter and mouseleave event emulation.
+		// example:
+		//		To use these events, you register a mouseenter like this:
+		//		|	define(["dojo/on", dojo/mouse"], function(on, mouse){
+		//		|		on(targetNode, mouse.enter, function(event){
+		//		|			dojo.addClass(targetNode, "highlighted");
+		//		|		});
+		//		|		on(targetNode, mouse.leave, function(event){
+		//		|			dojo.removeClass(targetNode, "highlighted");
+		//		|		});
+
+		_eventHandler: eventHandler,		// for dojo/touch
+
+		// enter: Synthetic Event
+		//		This is an extension event for the mouseenter that IE provides, emulating the
+		//		behavior on other browsers.
+		enter: eventHandler("mouseover"),
+
+		// leave: Synthetic Event
+		//		This is an extension event for the mouseleave that IE provides, emulating the
+		//		behavior on other browsers.
+		leave: eventHandler("mouseout"),
+
+		// wheel: Normalized Mouse Wheel Event
+		//		This is an extension event for the mousewheel that non-Mozilla browsers provide,
+		//		emulating the behavior on Mozilla based browsers.
+		wheel: wheel,
+
+		isLeft: mouseButtons.isLeft,
+		/*=====
+		isLeft: function(){
+			// summary:
+			//		Test an event object (from a mousedown event) to see if the left button was pressed.
+		},
+		=====*/
+
+		isMiddle: mouseButtons.isMiddle,
+		/*=====
+		 isMiddle: function(){
+			 // summary:
+			 //		Test an event object (from a mousedown event) to see if the middle button was pressed.
+		 },
+		 =====*/
+
+		isRight: mouseButtons.isRight
+		/*=====
+		 , isRight: function(){
+			 // summary:
+			 //		Test an event object (from a mousedown event) to see if the right button was pressed.
+		 }
+		 =====*/
+	};
+});

debian/missing-sources/dojo/on.js

@@ -0,0 +1,531 @@
+define(["./has!dom-addeventlistener?:./aspect", "./_base/kernel", "./sniff"], function(aspect, dojo, has){
+
+	"use strict";
+	if(has("dom")){ // check to make sure we are in a browser, this module should work anywhere
+		var major = window.ScriptEngineMajorVersion;
+		has.add("jscript", major && (major() + ScriptEngineMinorVersion() / 10));
+		has.add("event-orientationchange", has("touch") && !has("android")); // TODO: how do we detect this?
+		has.add("event-stopimmediatepropagation", window.Event && !!window.Event.prototype && !!window.Event.prototype.stopImmediatePropagation);
+		has.add("event-focusin", function(global, doc, element){
+			// All browsers except firefox support focusin, but too hard to feature test webkit since element.onfocusin
+			// is undefined.  Just return true for IE and use fallback path for other browsers.
+			return !!element.attachEvent;
+		});
+	}
+	var on = function(target, type, listener, dontFix){
+		// summary:
+		//		A function that provides core event listening functionality. With this function
+		//		you can provide a target, event type, and listener to be notified of
+		//		future matching events that are fired.
+		// target: Element|Object
+		//		This is the target object or DOM element that to receive events from
+		// type: String|Function
+		//		This is the name of the event to listen for or an extension event type.
+		// listener: Function
+		//		This is the function that should be called when the event fires.
+		// returns: Object
+		//		An object with a remove() method that can be used to stop listening for this
+		//		event.
+		// description:
+		//		To listen for "click" events on a button node, we can do:
+		//		|	define(["dojo/on"], function(listen){
+		//		|		on(button, "click", clickHandler);
+		//		|		...
+		//		Evented JavaScript objects can also have their own events.
+		//		|	var obj = new Evented;
+		//		|	on(obj, "foo", fooHandler);
+		//		And then we could publish a "foo" event:
+		//		|	on.emit(obj, "foo", {key: "value"});
+		//		We can use extension events as well. For example, you could listen for a tap gesture:
+		//		|	define(["dojo/on", "dojo/gesture/tap", function(listen, tap){
+		//		|		on(button, tap, tapHandler);
+		//		|		...
+		//		which would trigger fooHandler. Note that for a simple object this is equivalent to calling:
+		//		|	obj.onfoo({key:"value"});
+		//		If you use on.emit on a DOM node, it will use native event dispatching when possible.
+
+		if(typeof target.on == "function" && typeof type != "function" && !target.nodeType){
+			// delegate to the target's on() method, so it can handle it's own listening if it wants (unless it 
+			// is DOM node and we may be dealing with jQuery or Prototype's incompatible addition to the
+			// Element prototype 
+			return target.on(type, listener);
+		}
+		// delegate to main listener code
+		return on.parse(target, type, listener, addListener, dontFix, this);
+	};
+	on.pausable =  function(target, type, listener, dontFix){
+		// summary:
+		//		This function acts the same as on(), but with pausable functionality. The
+		//		returned signal object has pause() and resume() functions. Calling the
+		//		pause() method will cause the listener to not be called for future events. Calling the
+		//		resume() method will cause the listener to again be called for future events.
+		var paused;
+		var signal = on(target, type, function(){
+			if(!paused){
+				return listener.apply(this, arguments);
+			}
+		}, dontFix);
+		signal.pause = function(){
+			paused = true;
+		};
+		signal.resume = function(){
+			paused = false;
+		};
+		return signal;
+	};
+	on.once = function(target, type, listener, dontFix){
+		// summary:
+		//		This function acts the same as on(), but will only call the listener once. The 
+		//		listener will be called for the first
+		//		event that takes place and then listener will automatically be removed.
+		var signal = on(target, type, function(){
+			// remove this listener
+			signal.remove();
+			// proceed to call the listener
+			return listener.apply(this, arguments);
+		});
+		return signal;
+	};
+	on.parse = function(target, type, listener, addListener, dontFix, matchesTarget){
+		if(type.call){
+			// event handler function
+			// on(node, touch.press, touchListener);
+			return type.call(matchesTarget, target, listener);
+		}
+
+		if(type.indexOf(",") > -1){
+			// we allow comma delimited event names, so you can register for multiple events at once
+			var events = type.split(/\s*,\s*/);
+			var handles = [];
+			var i = 0;
+			var eventName;
+			while(eventName = events[i++]){
+				handles.push(addListener(target, eventName, listener, dontFix, matchesTarget));
+			}
+			handles.remove = function(){
+				for(var i = 0; i < handles.length; i++){
+					handles[i].remove();
+				}
+			};
+			return handles;
+		}
+		return addListener(target, type, listener, dontFix, matchesTarget);
+	};
+	var touchEvents = /^touch/;
+	function addListener(target, type, listener, dontFix, matchesTarget){
+		// event delegation:
+		var selector = type.match(/(.*):(.*)/);
+		// if we have a selector:event, the last one is interpreted as an event, and we use event delegation
+		if(selector){
+			type = selector[2];
+			selector = selector[1];
+			// create the extension event for selectors and directly call it
+			return on.selector(selector, type).call(matchesTarget, target, listener);
+		}
+		// test to see if it a touch event right now, so we don't have to do it every time it fires
+		if(has("touch")){
+			if(touchEvents.test(type)){
+				// touch event, fix it
+				listener = fixTouchListener(listener);
+			}
+			if(!has("event-orientationchange") && (type == "orientationchange")){
+				//"orientationchange" not supported <= Android 2.1, 
+				//but works through "resize" on window
+				type = "resize"; 
+				target = window;
+				listener = fixTouchListener(listener);
+			} 
+		}
+		if(addStopImmediate){
+			// add stopImmediatePropagation if it doesn't exist
+			listener = addStopImmediate(listener);
+		}
+		// normal path, the target is |this|
+		if(target.addEventListener){
+			// the target has addEventListener, which should be used if available (might or might not be a node, non-nodes can implement this method as well)
+			// check for capture conversions
+			var capture = type in captures,
+				adjustedType = capture ? captures[type] : type;
+			target.addEventListener(adjustedType, listener, capture);
+			// create and return the signal
+			return {
+				remove: function(){
+					target.removeEventListener(adjustedType, listener, capture);
+				}
+			};
+		}
+		type = "on" + type;
+		if(fixAttach && target.attachEvent){
+			return fixAttach(target, type, listener);
+		}
+		throw new Error("Target must be an event emitter");
+	}
+
+	on.selector = function(selector, eventType, children){
+		// summary:
+		//		Creates a new extension event with event delegation. This is based on
+		//		the provided event type (can be extension event) that
+		//		only calls the listener when the CSS selector matches the target of the event.
+		//
+		//		The application must require() an appropriate level of dojo/query to handle the selector.
+		// selector:
+		//		The CSS selector to use for filter events and determine the |this| of the event listener.
+		// eventType:
+		//		The event to listen for
+		// children:
+		//		Indicates if children elements of the selector should be allowed. This defaults to 
+		//		true
+		// example:
+		// |	require(["dojo/on", "dojo/mouse", "dojo/query!css2"], function(listen, mouse){
+		// |		on(node, on.selector(".my-class", mouse.enter), handlerForMyHover);
+		return function(target, listener){
+			// if the selector is function, use it to select the node, otherwise use the matches method
+			var matchesTarget = typeof selector == "function" ? {matches: selector} : this,
+				bubble = eventType.bubble;
+			function select(eventTarget){
+				// see if we have a valid matchesTarget or default to dojo.query
+				matchesTarget = matchesTarget && matchesTarget.matches ? matchesTarget : dojo.query;
+				// there is a selector, so make sure it matches
+				while(!matchesTarget.matches(eventTarget, selector, target)){
+					if(eventTarget == target || children === false || !(eventTarget = eventTarget.parentNode) || eventTarget.nodeType != 1){ // intentional assignment
+						return;
+					}
+				}
+				return eventTarget;
+			}
+			if(bubble){
+				// the event type doesn't naturally bubble, but has a bubbling form, use that, and give it the selector so it can perform the select itself
+				return on(target, bubble(select), listener);
+			}
+			// standard event delegation
+			return on(target, eventType, function(event){
+				// call select to see if we match
+				var eventTarget = select(event.target);
+				// if it matches we call the listener
+				return eventTarget && listener.call(eventTarget, event);
+			});
+		};
+	};
+
+	function syntheticPreventDefault(){
+		this.cancelable = false;
+		this.defaultPrevented = true;
+	}
+	function syntheticStopPropagation(){
+		this.bubbles = false;
+	}
+	var slice = [].slice,
+		syntheticDispatch = on.emit = function(target, type, event){
+		// summary:
+		//		Fires an event on the target object.
+		// target:
+		//		The target object to fire the event on. This can be a DOM element or a plain 
+		//		JS object. If the target is a DOM element, native event emitting mechanisms
+		//		are used when possible.
+		// type:
+		//		The event type name. You can emulate standard native events like "click" and 
+		//		"mouseover" or create custom events like "open" or "finish".
+		// event:
+		//		An object that provides the properties for the event. See https://developer.mozilla.org/en/DOM/event.initEvent 
+		//		for some of the properties. These properties are copied to the event object.
+		//		Of particular importance are the cancelable and bubbles properties. The
+		//		cancelable property indicates whether or not the event has a default action
+		//		that can be cancelled. The event is cancelled by calling preventDefault() on
+		//		the event object. The bubbles property indicates whether or not the
+		//		event will bubble up the DOM tree. If bubbles is true, the event will be called
+		//		on the target and then each parent successively until the top of the tree
+		//		is reached or stopPropagation() is called. Both bubbles and cancelable 
+		//		default to false.
+		// returns:
+		//		If the event is cancelable and the event is not cancelled,
+		//		emit will return true. If the event is cancelable and the event is cancelled,
+		//		emit will return false.
+		// details:
+		//		Note that this is designed to emit events for listeners registered through
+		//		dojo/on. It should actually work with any event listener except those
+		//		added through IE's attachEvent (IE8 and below's non-W3C event emitting
+		//		doesn't support custom event types). It should work with all events registered
+		//		through dojo/on. Also note that the emit method does do any default
+		//		action, it only returns a value to indicate if the default action should take
+		//		place. For example, emitting a keypress event would not cause a character
+		//		to appear in a textbox.
+		// example:
+		//		To fire our own click event
+		//	|	on.emit(dojo.byId("button"), "click", {
+		//	|		cancelable: true,
+		//	|		bubbles: true,
+		//	|		screenX: 33,
+		//	|		screenY: 44
+		//	|	});
+		//		We can also fire our own custom events:
+		//	|	on.emit(dojo.byId("slider"), "slide", {
+		//	|		cancelable: true,
+		//	|		bubbles: true,
+		//	|		direction: "left-to-right"
+		//	|	});
+		var args = slice.call(arguments, 2);
+		var method = "on" + type;
+		if("parentNode" in target){
+			// node (or node-like), create event controller methods
+			var newEvent = args[0] = {};
+			for(var i in event){
+				newEvent[i] = event[i];
+			}
+			newEvent.preventDefault = syntheticPreventDefault;
+			newEvent.stopPropagation = syntheticStopPropagation;
+			newEvent.target = target;
+			newEvent.type = type;
+			event = newEvent;
+		}
+		do{
+			// call any node which has a handler (note that ideally we would try/catch to simulate normal event propagation but that causes too much pain for debugging)
+			target[method] && target[method].apply(target, args);
+			// and then continue up the parent node chain if it is still bubbling (if started as bubbles and stopPropagation hasn't been called)
+		}while(event && event.bubbles && (target = target.parentNode));
+		return event && event.cancelable && event; // if it is still true (was cancelable and was cancelled), return the event to indicate default action should happen
+	};
+	var captures = has("event-focusin") ? {} : {focusin: "focus", focusout: "blur"};
+	if(!has("event-stopimmediatepropagation")){
+		var stopImmediatePropagation =function(){
+			this.immediatelyStopped = true;
+			this.modified = true; // mark it as modified so the event will be cached in IE
+		};
+		var addStopImmediate = function(listener){
+			return function(event){
+				if(!event.immediatelyStopped){// check to make sure it hasn't been stopped immediately
+					event.stopImmediatePropagation = stopImmediatePropagation;
+					return listener.apply(this, arguments);
+				}
+			};
+		}
+	} 
+	if(has("dom-addeventlistener")){
+		// emitter that works with native event handling
+		on.emit = function(target, type, event){
+			if(target.dispatchEvent && document.createEvent){
+				// use the native event emitting mechanism if it is available on the target object
+				// create a generic event				
+				// we could create branch into the different types of event constructors, but 
+				// that would be a lot of extra code, with little benefit that I can see, seems 
+				// best to use the generic constructor and copy properties over, making it 
+				// easy to have events look like the ones created with specific initializers
+				var nativeEvent = target.ownerDocument.createEvent("HTMLEvents");
+				nativeEvent.initEvent(type, !!event.bubbles, !!event.cancelable);
+				// and copy all our properties over
+				for(var i in event){
+					if(!(i in nativeEvent)){
+						nativeEvent[i] = event[i];
+					}
+				}
+				return target.dispatchEvent(nativeEvent) && nativeEvent;
+			}
+			return syntheticDispatch.apply(on, arguments); // emit for a non-node
+		};
+	}else{
+		// no addEventListener, basically old IE event normalization
+		on._fixEvent = function(evt, sender){
+			// summary:
+			//		normalizes properties on the event object including event
+			//		bubbling methods, keystroke normalization, and x/y positions
+			// evt:
+			//		native event object
+			// sender:
+			//		node to treat as "currentTarget"
+			if(!evt){
+				var w = sender && (sender.ownerDocument || sender.document || sender).parentWindow || window;
+				evt = w.event;
+			}
+			if(!evt){return evt;}
+			try{
+				if(lastEvent && evt.type == lastEvent.type  && evt.srcElement == lastEvent.target){
+					// should be same event, reuse event object (so it can be augmented);
+					// accessing evt.srcElement rather than evt.target since evt.target not set on IE until fixup below
+					evt = lastEvent;
+				}
+			}catch(e){
+				// will occur on IE on lastEvent.type reference if lastEvent points to a previous event that already
+				// finished bubbling, but the setTimeout() to clear lastEvent hasn't fired yet
+			}
+			if(!evt.target){ // check to see if it has been fixed yet
+				evt.target = evt.srcElement;
+				evt.currentTarget = (sender || evt.srcElement);
+				if(evt.type == "mouseover"){
+					evt.relatedTarget = evt.fromElement;
+				}
+				if(evt.type == "mouseout"){
+					evt.relatedTarget = evt.toElement;
+				}
+				if(!evt.stopPropagation){
+					evt.stopPropagation = stopPropagation;
+					evt.preventDefault = preventDefault;
+				}
+				switch(evt.type){
+					case "keypress":
+						var c = ("charCode" in evt ? evt.charCode : evt.keyCode);
+						if (c==10){
+							// CTRL-ENTER is CTRL-ASCII(10) on IE, but CTRL-ENTER on Mozilla
+							c=0;
+							evt.keyCode = 13;
+						}else if(c==13||c==27){
+							c=0; // Mozilla considers ENTER and ESC non-printable
+						}else if(c==3){
+							c=99; // Mozilla maps CTRL-BREAK to CTRL-c
+						}
+						// Mozilla sets keyCode to 0 when there is a charCode
+						// but that stops the event on IE.
+						evt.charCode = c;
+						_setKeyChar(evt);
+						break;
+				}
+			}
+			return evt;
+		};
+		var lastEvent, IESignal = function(handle){
+			this.handle = handle;
+		};
+		IESignal.prototype.remove = function(){
+			delete _dojoIEListeners_[this.handle];
+		};
+		var fixListener = function(listener){
+			// this is a minimal function for closing on the previous listener with as few as variables as possible
+			return function(evt){
+				evt = on._fixEvent(evt, this);
+				var result = listener.call(this, evt);
+				if(evt.modified){
+					// cache the last event and reuse it if we can
+					if(!lastEvent){
+						setTimeout(function(){
+							lastEvent = null;
+						});
+					}
+					lastEvent = evt;
+				}
+				return result;
+			};
+		};
+		var fixAttach = function(target, type, listener){
+			listener = fixListener(listener);
+			if(((target.ownerDocument ? target.ownerDocument.parentWindow : target.parentWindow || target.window || window) != top || 
+						has("jscript") < 5.8) && 
+					!has("config-_allow_leaks")){
+				// IE will leak memory on certain handlers in frames (IE8 and earlier) and in unattached DOM nodes for JScript 5.7 and below.
+				// Here we use global redirection to solve the memory leaks
+				if(typeof _dojoIEListeners_ == "undefined"){
+					_dojoIEListeners_ = [];
+				}
+				var emitter = target[type];
+				if(!emitter || !emitter.listeners){
+					var oldListener = emitter;
+					emitter = Function('event', 'var callee = arguments.callee; for(var i = 0; i<callee.listeners.length; i++){var listener = _dojoIEListeners_[callee.listeners[i]]; if(listener){listener.call(this,event);}}');
+					emitter.listeners = [];
+					target[type] = emitter;
+					emitter.global = this;
+					if(oldListener){
+						emitter.listeners.push(_dojoIEListeners_.push(oldListener) - 1);
+					}
+				}
+				var handle;
+				emitter.listeners.push(handle = (emitter.global._dojoIEListeners_.push(listener) - 1));
+				return new IESignal(handle);
+			}
+			return aspect.after(target, type, listener, true);
+		};
+
+		var _setKeyChar = function(evt){
+			evt.keyChar = evt.charCode ? String.fromCharCode(evt.charCode) : '';
+			evt.charOrCode = evt.keyChar || evt.keyCode;
+		};
+		// Called in Event scope
+		var stopPropagation = function(){
+			this.cancelBubble = true;
+		};
+		var preventDefault = on._preventDefault = function(){
+			// Setting keyCode to 0 is the only way to prevent certain keypresses (namely
+			// ctrl-combinations that correspond to menu accelerator keys).
+			// Otoh, it prevents upstream listeners from getting this information
+			// Try to split the difference here by clobbering keyCode only for ctrl
+			// combinations. If you still need to access the key upstream, bubbledKeyCode is
+			// provided as a workaround.
+			this.bubbledKeyCode = this.keyCode;
+			if(this.ctrlKey){
+				try{
+					// squelch errors when keyCode is read-only
+					// (e.g. if keyCode is ctrl or shift)
+					this.keyCode = 0;
+				}catch(e){
+				}
+			}
+			this.defaultPrevented = true;
+			this.returnValue = false;
+			this.modified = true; // mark it as modified  (for defaultPrevented flag) so the event will be cached in IE
+		};
+	}
+	if(has("touch")){ 
+		var Event = function(){};
+		var windowOrientation = window.orientation; 
+		var fixTouchListener = function(listener){ 
+			return function(originalEvent){ 
+				//Event normalization(for ontouchxxx and resize): 
+				//1.incorrect e.pageX|pageY in iOS 
+				//2.there are no "e.rotation", "e.scale" and "onorientationchange" in Android
+				//3.More TBD e.g. force | screenX | screenX | clientX | clientY | radiusX | radiusY
+
+				// see if it has already been corrected
+				var event = originalEvent.corrected;
+				if(!event){
+					var type = originalEvent.type;
+					try{
+						delete originalEvent.type; // on some JS engines (android), deleting properties make them mutable
+					}catch(e){} 
+					if(originalEvent.type){
+						// deleting properties doesn't work (older iOS), have to use delegation
+						if(has('mozilla')){
+							// Firefox doesn't like delegated properties, so we have to copy
+							var event = {};
+							for(var name in originalEvent){
+								event[name] = originalEvent[name];
+							}
+						}else{
+							// old iOS branch
+							Event.prototype = originalEvent;
+							var event = new Event;
+						}
+						// have to delegate methods to make them work
+						event.preventDefault = function(){
+							originalEvent.preventDefault();
+						};
+						event.stopPropagation = function(){
+							originalEvent.stopPropagation();
+						};
+					}else{
+						// deletion worked, use property as is
+						event = originalEvent;
+						event.type = type;
+					}
+					originalEvent.corrected = event;
+					if(type == 'resize'){
+						if(windowOrientation == window.orientation){ 
+							return null;//double tap causes an unexpected 'resize' in Android
+						} 
+						windowOrientation = window.orientation;
+						event.type = "orientationchange"; 
+						return listener.call(this, event);
+					}
+					// We use the original event and augment, rather than doing an expensive mixin operation
+					if(!("rotation" in event)){ // test to see if it has rotation
+						event.rotation = 0; 
+						event.scale = 1;
+					}
+					//use event.changedTouches[0].pageX|pageY|screenX|screenY|clientX|clientY|target
+					var firstChangeTouch = event.changedTouches[0];
+					for(var i in firstChangeTouch){ // use for-in, we don't need to have dependency on dojo/_base/lang here
+						delete event[i]; // delete it first to make it mutable
+						event[i] = firstChangeTouch[i];
+					}
+				}
+				return listener.call(this, event); 
+			}; 
+		}; 
+	}
+	return on;
+});

debian/missing-sources/dojo/promise/Promise.js

@@ -0,0 +1,133 @@
+define([
+	"../_base/lang"
+], function(lang){
+	"use strict";
+
+	// module:
+	//		dojo/promise/Promise
+
+	function throwAbstract(){
+		throw new TypeError("abstract");
+	}
+
+	return lang.extend(function Promise(){
+		// summary:
+		//		The public interface to a deferred.
+		// description:
+		//		The public interface to a deferred. All promises in Dojo are
+		//		instances of this class.
+	}, {
+		then: function(callback, errback, progback){
+			// summary:
+			//		Add new callbacks to the promise.
+			// description:
+			//		Add new callbacks to the deferred. Callbacks can be added
+			//		before or after the deferred is fulfilled.
+			// callback: Function?
+			//		Callback to be invoked when the promise is resolved.
+			//		Receives the resolution value.
+			// errback: Function?
+			//		Callback to be invoked when the promise is rejected.
+			//		Receives the rejection error.
+			// progback: Function?
+			//		Callback to be invoked when the promise emits a progress
+			//		update. Receives the progress update.
+			// returns: dojo/promise/Promise
+			//		Returns a new promise for the result of the callback(s).
+			//		This can be used for chaining many asynchronous operations.
+
+			throwAbstract();
+		},
+
+		cancel: function(reason, strict){
+			// summary:
+			//		Inform the deferred it may cancel its asynchronous operation.
+			// description:
+			//		Inform the deferred it may cancel its asynchronous operation.
+			//		The deferred's (optional) canceler is invoked and the
+			//		deferred will be left in a rejected state. Can affect other
+			//		promises that originate with the same deferred.
+			// reason: any
+			//		A message that may be sent to the deferred's canceler,
+			//		explaining why it's being canceled.
+			// strict: Boolean?
+			//		If strict, will throw an error if the deferred has already
+			//		been fulfilled and consequently cannot be canceled.
+			// returns: any
+			//		Returns the rejection reason if the deferred was canceled
+			//		normally.
+
+			throwAbstract();
+		},
+
+		isResolved: function(){
+			// summary:
+			//		Checks whether the promise has been resolved.
+			// returns: Boolean
+
+			throwAbstract();
+		},
+
+		isRejected: function(){
+			// summary:
+			//		Checks whether the promise has been rejected.
+			// returns: Boolean
+
+			throwAbstract();
+		},
+
+		isFulfilled: function(){
+			// summary:
+			//		Checks whether the promise has been resolved or rejected.
+			// returns: Boolean
+
+			throwAbstract();
+		},
+
+		isCanceled: function(){
+			// summary:
+			//		Checks whether the promise has been canceled.
+			// returns: Boolean
+
+			throwAbstract();
+		},
+
+		always: function(callbackOrErrback){
+			// summary:
+			//		Add a callback to be invoked when the promise is resolved
+			//		or rejected.
+			// callbackOrErrback: Function?
+			//		A function that is used both as a callback and errback.
+			// returns: dojo/promise/Promise
+			//		Returns a new promise for the result of the callback/errback.
+
+			return this.then(callbackOrErrback, callbackOrErrback);
+		},
+
+		otherwise: function(errback){
+			// summary:
+			//		Add new errbacks to the promise.
+			// errback: Function?
+			//		Callback to be invoked when the promise is rejected.
+			// returns: dojo/promise/Promise
+			//		Returns a new promise for the result of the errback.
+
+			return this.then(null, errback);
+		},
+
+		trace: function(){
+			return this;
+		},
+
+		traceRejected: function(){
+			return this;
+		},
+
+		toString: function(){
+			// returns: string
+			//		Returns `[object Promise]`.
+
+			return "[object Promise]";
+		}
+	});
+});

debian/missing-sources/dojo/promise/all.js

@@ -0,0 +1,76 @@
+define([
+	"../_base/array",
+	"../Deferred",
+	"../when"
+], function(array, Deferred, when){
+	"use strict";
+
+	// module:
+	//		dojo/promise/all
+
+	var some = array.some;
+
+	return function all(objectOrArray){
+		// summary:
+		//		Takes multiple promises and returns a new promise that is fulfilled
+		//		when all promises have been fulfilled.
+		// description:
+		//		Takes multiple promises and returns a new promise that is fulfilled
+		//		when all promises have been fulfilled. If one of the promises is rejected,
+		//		the returned promise is also rejected. Canceling the returned promise will
+		//		*not* cancel any passed promises.
+		// objectOrArray: Object|Array?
+		//		The promise will be fulfilled with a list of results if invoked with an
+		//		array, or an object of results when passed an object (using the same
+		//		keys). If passed neither an object or array it is resolved with an
+		//		undefined value.
+		// returns: dojo/promise/Promise
+
+		var object, array;
+		if(objectOrArray instanceof Array){
+			array = objectOrArray;
+		}else if(objectOrArray && typeof objectOrArray === "object"){
+			object = objectOrArray;
+		}
+
+		var results;
+		var keyLookup = [];
+		if(object){
+			array = [];
+			for(var key in object){
+				if(Object.hasOwnProperty.call(object, key)){
+					keyLookup.push(key);
+					array.push(object[key]);
+				}
+			}
+			results = {};
+		}else if(array){
+			results = [];
+		}
+
+		if(!array || !array.length){
+			return new Deferred().resolve(results);
+		}
+
+		var deferred = new Deferred();
+		deferred.promise.always(function(){
+			results = keyLookup = null;
+		});
+		var waiting = array.length;
+		some(array, function(valueOrPromise, index){
+			if(!object){
+				keyLookup.push(index);
+			}
+			when(valueOrPromise, function(value){
+				if(!deferred.isFulfilled()){
+					results[keyLookup[index]] = value;
+					if(--waiting === 0){
+						deferred.resolve(results);
+					}
+				}
+			}, deferred.reject);
+			return deferred.isFulfilled();
+		});
+		return deferred.promise;	// dojo/promise/Promise
+	};
+});

debian/missing-sources/dojo/promise/instrumentation.js

@@ -0,0 +1,105 @@
+define([
+	"./tracer",
+	"../has",
+	"../_base/lang",
+	"../_base/array"
+], function(tracer, has, lang, arrayUtil){
+	function logError(error, rejection, deferred){
+		var stack = "";
+		if(error && error.stack){
+			stack += error.stack;
+		}
+		if(rejection && rejection.stack){
+			stack += "\n    ----------------------------------------\n    rejected" + rejection.stack.split("\n").slice(1).join("\n").replace(/^\s+/, " ");
+		}
+		if(deferred && deferred.stack){
+			stack += "\n    ----------------------------------------\n" + deferred.stack;
+		}
+		console.error(error, stack);
+	}
+
+	function reportRejections(error, handled, rejection, deferred){
+		if(!handled){
+			logError(error, rejection, deferred);
+		}
+	}
+
+	var errors = [];
+	var activeTimeout = false;
+	var unhandledWait = 1000;
+	function trackUnhandledRejections(error, handled, rejection, deferred){
+		if(handled){
+			arrayUtil.some(errors, function(obj, ix){
+				if(obj.error === error){
+					errors.splice(ix, 1);
+					return true;
+				}
+			});
+		}else if(!arrayUtil.some(errors, function(obj){ return obj.error === error; })){
+			errors.push({
+				error: error,
+				rejection: rejection,
+				deferred: deferred,
+				timestamp: new Date().getTime()
+			});
+		}
+
+		if(!activeTimeout){
+			activeTimeout = setTimeout(logRejected, unhandledWait);
+		}
+	}
+
+	function logRejected(){
+		var now = new Date().getTime();
+		var reportBefore = now - unhandledWait;
+		errors = arrayUtil.filter(errors, function(obj){
+			if(obj.timestamp < reportBefore){
+				logError(obj.error, obj.rejection, obj.deferred);
+				return false;
+			}
+			return true;
+		});
+
+		if(errors.length){
+			activeTimeout = setTimeout(logRejected, errors[0].timestamp + unhandledWait - now);
+		}else{
+			activeTimeout = false;
+		}
+	}
+
+	return function(Deferred){
+		// summary:
+		//		Initialize instrumentation for the Deferred class.
+		// description:
+		//		Initialize instrumentation for the Deferred class.
+		//		Done automatically by `dojo/Deferred` if the
+		//		`deferredInstrumentation` and `useDeferredInstrumentation`
+		//		config options are set.
+		//
+		//		Sets up `dojo/promise/tracer` to log to the console.
+		//
+		//		Sets up instrumentation of rejected deferreds so unhandled
+		//		errors are logged to the console.
+
+		var usage = has("config-useDeferredInstrumentation");
+		if(usage){
+			tracer.on("resolved", lang.hitch(console, "log", "resolved"));
+			tracer.on("rejected", lang.hitch(console, "log", "rejected"));
+			tracer.on("progress", lang.hitch(console, "log", "progress"));
+
+			var args = [];
+			if(typeof usage === "string"){
+				args = usage.split(",");
+				usage = args.shift();
+			}
+			if(usage === "report-rejections"){
+				Deferred.instrumentRejected = reportRejections;
+			}else if(usage === "report-unhandled-rejections" || usage === true || usage === 1){
+				Deferred.instrumentRejected = trackUnhandledRejections;
+				unhandledWait = parseInt(args[0], 10) || unhandledWait;
+			}else{
+				throw new Error("Unsupported instrumentation usage <" + usage + ">");
+			}
+		}
+	};
+});

debian/missing-sources/dojo/promise/tracer.js

@@ -0,0 +1,85 @@
+define([
+	"../_base/lang",
+	"./Promise",
+	"../Evented"
+], function(lang, Promise, Evented){
+	"use strict";
+
+	// module:
+	//		dojo/promise/tracer
+
+	/*=====
+	return {
+		// summary:
+		//		Trace promise fulfillment.
+		// description:
+		//		Trace promise fulfillment. Calling `.trace()` or `.traceError()` on a
+		//		promise enables tracing. Will emit `resolved`, `rejected` or `progress`
+		//		events.
+
+		on: function(type, listener){
+			// summary:
+			//		Subscribe to traces.
+			// description:
+			//		See `dojo/Evented#on()`.
+			// type: String
+			//		`resolved`, `rejected`, or `progress`
+			// listener: Function
+			//		The listener is passed the traced value and any arguments
+			//		that were used with the `.trace()` call.
+		}
+	};
+	=====*/
+
+	var evented = new Evented;
+	var emit = evented.emit;
+	evented.emit = null;
+	// Emit events asynchronously since they should not change the promise state.
+	function emitAsync(args){
+		setTimeout(function(){
+			emit.apply(evented, args);
+		}, 0);
+	}
+
+	Promise.prototype.trace = function(){
+		// summary:
+		//		Trace the promise.
+		// description:
+		//		Tracing allows you to transparently log progress,
+		//		resolution and rejection of promises, without affecting the
+		//		promise itself. Any arguments passed to `trace()` are
+		//		emitted in trace events. See `dojo/promise/tracer` on how
+		//		to handle traces.
+		// returns: dojo/promise/Promise
+		//		The promise instance `trace()` is called on.
+
+		var args = lang._toArray(arguments);
+		this.then(
+			function(value){ emitAsync(["resolved", value].concat(args)); },
+			function(error){ emitAsync(["rejected", error].concat(args)); },
+			function(update){ emitAsync(["progress", update].concat(args)); }
+		);
+		return this;
+	};
+
+	Promise.prototype.traceRejected = function(){
+		// summary:
+		//		Trace rejection of the promise.
+		// description:
+		//		Tracing allows you to transparently log progress,
+		//		resolution and rejection of promises, without affecting the
+		//		promise itself. Any arguments passed to `trace()` are
+		//		emitted in trace events. See `dojo/promise/tracer` on how
+		//		to handle traces.
+		// returns: dojo/promise/Promise
+		//		The promise instance `traceRejected()` is called on.
+
+		var args = lang._toArray(arguments);
+		this.otherwise(function(error){
+			emitAsync(["rejected", error].concat(args));
+		});
+		return this;
+	};
+
+	return evented;
+});

debian/missing-sources/dojo/query.js

@@ -0,0 +1,705 @@
+define(["./_base/kernel", "./has", "./dom", "./on", "./_base/array", "./_base/lang", "./selector/_loader", "./selector/_loader!default"],
+	function(dojo, has, dom, on, array, lang, loader, defaultEngine){
+
+	"use strict";
+
+	has.add("array-extensible", function(){
+		// test to see if we can extend an array (not supported in old IE)
+		return lang.delegate([], {length: 1}).length == 1 && !has("bug-for-in-skips-shadowed");
+	});
+	
+	var ap = Array.prototype, aps = ap.slice, apc = ap.concat, forEach = array.forEach;
+
+	var tnl = function(/*Array*/ a, /*dojo/NodeList?*/ parent, /*Function?*/ NodeListCtor){
+		// summary:
+		//		decorate an array to make it look like a `dojo/NodeList`.
+		// a:
+		//		Array of nodes to decorate.
+		// parent:
+		//		An optional parent NodeList that generated the current
+		//		list of nodes. Used to call _stash() so the parent NodeList
+		//		can be accessed via end() later.
+		// NodeListCtor:
+		//		An optional constructor function to use for any
+		//		new NodeList calls. This allows a certain chain of
+		//		NodeList calls to use a different object than dojo/NodeList.
+		var nodeList = new (NodeListCtor || this._NodeListCtor || nl)(a);
+		return parent ? nodeList._stash(parent) : nodeList;
+	};
+
+	var loopBody = function(f, a, o){
+		a = [0].concat(aps.call(a, 0));
+		o = o || dojo.global;
+		return function(node){
+			a[0] = node;
+			return f.apply(o, a);
+		};
+	};
+
+	// adapters
+
+	var adaptAsForEach = function(f, o){
+		// summary:
+		//		adapts a single node function to be used in the forEach-type
+		//		actions. The initial object is returned from the specialized
+		//		function.
+		// f: Function
+		//		a function to adapt
+		// o: Object?
+		//		an optional context for f
+		return function(){
+			this.forEach(loopBody(f, arguments, o));
+			return this;	// Object
+		};
+	};
+
+	var adaptAsMap = function(f, o){
+		// summary:
+		//		adapts a single node function to be used in the map-type
+		//		actions. The return is a new array of values, as via `dojo.map`
+		// f: Function
+		//		a function to adapt
+		// o: Object?
+		//		an optional context for f
+		return function(){
+			return this.map(loopBody(f, arguments, o));
+		};
+	};
+
+	var adaptAsFilter = function(f, o){
+		// summary:
+		//		adapts a single node function to be used in the filter-type actions
+		// f: Function
+		//		a function to adapt
+		// o: Object?
+		//		an optional context for f
+		return function(){
+			return this.filter(loopBody(f, arguments, o));
+		};
+	};
+
+	var adaptWithCondition = function(f, g, o){
+		// summary:
+		//		adapts a single node function to be used in the map-type
+		//		actions, behaves like forEach() or map() depending on arguments
+		// f: Function
+		//		a function to adapt
+		// g: Function
+		//		a condition function, if true runs as map(), otherwise runs as forEach()
+		// o: Object?
+		//		an optional context for f and g
+		return function(){
+			var a = arguments, body = loopBody(f, a, o);
+			if(g.call(o || dojo.global, a)){
+				return this.map(body);	// self
+			}
+			this.forEach(body);
+			return this;	// self
+		};
+	};
+
+	var NodeList = function(array){
+		// summary:
+		//		Array-like object which adds syntactic
+		//		sugar for chaining, common iteration operations, animation, and
+		//		node manipulation. NodeLists are most often returned as the
+		//		result of dojo.query() calls.
+		// description:
+		//		NodeList instances provide many utilities that reflect
+		//		core Dojo APIs for Array iteration and manipulation, DOM
+		//		manipulation, and event handling. Instead of needing to dig up
+		//		functions in the dojo.* namespace, NodeLists generally make the
+		//		full power of Dojo available for DOM manipulation tasks in a
+		//		simple, chainable way.
+		// example:
+		//		create a node list from a node
+		//		|	new query.NodeList(dojo.byId("foo"));
+		// example:
+		//		get a NodeList from a CSS query and iterate on it
+		//		|	var l = dojo.query(".thinger");
+		//		|	l.forEach(function(node, index, nodeList){
+		//		|		console.log(index, node.innerHTML);
+		//		|	});
+		// example:
+		//		use native and Dojo-provided array methods to manipulate a
+		//		NodeList without needing to use dojo.* functions explicitly:
+		//		|	var l = dojo.query(".thinger");
+		//		|	// since NodeLists are real arrays, they have a length
+		//		|	// property that is both readable and writable and
+		//		|	// push/pop/shift/unshift methods
+		//		|	console.log(l.length);
+		//		|	l.push(dojo.create("span"));
+		//		|
+		//		|	// dojo's normalized array methods work too:
+		//		|	console.log( l.indexOf(dojo.byId("foo")) );
+		//		|	// ...including the special "function as string" shorthand
+		//		|	console.log( l.every("item.nodeType == 1") );
+		//		|
+		//		|	// NodeLists can be [..] indexed, or you can use the at()
+		//		|	// function to get specific items wrapped in a new NodeList:
+		//		|	var node = l[3]; // the 4th element
+		//		|	var newList = l.at(1, 3); // the 2nd and 4th elements
+		// example:
+		//		the style functions you expect are all there too:
+		//		|	// style() as a getter...
+		//		|	var borders = dojo.query(".thinger").style("border");
+		//		|	// ...and as a setter:
+		//		|	dojo.query(".thinger").style("border", "1px solid black");
+		//		|	// class manipulation
+		//		|	dojo.query("li:nth-child(even)").addClass("even");
+		//		|	// even getting the coordinates of all the items
+		//		|	var coords = dojo.query(".thinger").coords();
+		// example:
+		//		DOM manipulation functions from the dojo.* namespace area also available:
+		//		|	// remove all of the elements in the list from their
+		//		|	// parents (akin to "deleting" them from the document)
+		//		|	dojo.query(".thinger").orphan();
+		//		|	// place all elements in the list at the front of #foo
+		//		|	dojo.query(".thinger").place("foo", "first");
+		// example:
+		//		Event handling couldn't be easier. `dojo.connect` is mapped in,
+		//		and shortcut handlers are provided for most DOM events:
+		//		|	// like dojo.connect(), but with implicit scope
+		//		|	dojo.query("li").connect("onclick", console, "log");
+		//		|
+		//		|	// many common event handlers are already available directly:
+		//		|	dojo.query("li").onclick(console, "log");
+		//		|	var toggleHovered = dojo.hitch(dojo, "toggleClass", "hovered");
+		//		|	dojo.query("p")
+		//		|		.onmouseenter(toggleHovered)
+		//		|		.onmouseleave(toggleHovered);
+		// example:
+		//		chainability is a key advantage of NodeLists:
+		//		|	dojo.query(".thinger")
+		//		|		.onclick(function(e){ /* ... */ })
+		//		|		.at(1, 3, 8) // get a subset
+		//		|			.style("padding", "5px")
+		//		|			.forEach(console.log);
+		var isNew = this instanceof nl && has("array-extensible");
+		if(typeof array == "number"){
+			array = Array(array);
+		}
+		var nodeArray = (array && "length" in array) ? array : arguments;
+		if(isNew || !nodeArray.sort){
+			// make sure it's a real array before we pass it on to be wrapped 
+			var target = isNew ? this : [],
+				l = target.length = nodeArray.length;
+			for(var i = 0; i < l; i++){
+				target[i] = nodeArray[i];
+			}
+			if(isNew){
+				// called with new operator, this means we are going to use this instance and push
+				// the nodes on to it. This is usually much faster since the NodeList properties
+				//	don't need to be copied (unless the list of nodes is extremely large).
+				return target;
+			}
+			nodeArray = target;
+		}
+		// called without new operator, use a real array and copy prototype properties,
+		// this is slower and exists for back-compat. Should be removed in 2.0.
+		lang._mixin(nodeArray, nlp);
+		nodeArray._NodeListCtor = function(array){
+			// call without new operator to preserve back-compat behavior
+			return nl(array);
+		};
+		return nodeArray;
+	};
+	
+	var nl = NodeList, nlp = nl.prototype = 
+		has("array-extensible") ? [] : {};// extend an array if it is extensible
+
+	// expose adapters and the wrapper as private functions
+
+	nl._wrap = nlp._wrap = tnl;
+	nl._adaptAsMap = adaptAsMap;
+	nl._adaptAsForEach = adaptAsForEach;
+	nl._adaptAsFilter  = adaptAsFilter;
+	nl._adaptWithCondition = adaptWithCondition;
+
+	// mass assignment
+
+	// add array redirectors
+	forEach(["slice", "splice"], function(name){
+		var f = ap[name];
+		//Use a copy of the this array via this.slice() to allow .end() to work right in the splice case.
+		// CANNOT apply ._stash()/end() to splice since it currently modifies
+		// the existing this array -- it would break backward compatibility if we copy the array before
+		// the splice so that we can use .end(). So only doing the stash option to this._wrap for slice.
+		nlp[name] = function(){ return this._wrap(f.apply(this, arguments), name == "slice" ? this : null); };
+	});
+	// concat should be here but some browsers with native NodeList have problems with it
+
+	// add array.js redirectors
+	forEach(["indexOf", "lastIndexOf", "every", "some"], function(name){
+		var f = array[name];
+		nlp[name] = function(){ return f.apply(dojo, [this].concat(aps.call(arguments, 0))); };
+	});
+
+	lang.extend(NodeList, {
+		// copy the constructors
+		constructor: nl,
+		_NodeListCtor: nl,
+		toString: function(){
+			// Array.prototype.toString can't be applied to objects, so we use join
+			return this.join(",");
+		},
+		_stash: function(parent){
+			// summary:
+			//		private function to hold to a parent NodeList. end() to return the parent NodeList.
+			//
+			// example:
+			//		How to make a `dojo/NodeList` method that only returns the third node in
+			//		the dojo/NodeList but allows access to the original NodeList by using this._stash:
+			//	|	dojo.extend(NodeList, {
+			//	|		third: function(){
+			//	|			var newNodeList = NodeList(this[2]);
+			//	|			return newNodeList._stash(this);
+			//	|		}
+			//	|	});
+			//	|	// then see how _stash applies a sub-list, to be .end()'ed out of
+			//	|	dojo.query(".foo")
+			//	|		.third()
+			//	|			.addClass("thirdFoo")
+			//	|		.end()
+			//	|		// access to the orig .foo list
+			//	|		.removeClass("foo")
+			//	|
+			//
+			this._parent = parent;
+			return this; // dojo/NodeList
+		},
+
+		on: function(eventName, listener){
+			// summary:
+			//		Listen for events on the nodes in the NodeList. Basic usage is:
+			//		| query(".my-class").on("click", listener);
+			//		This supports event delegation by using selectors as the first argument with the event names as
+			//		pseudo selectors. For example:
+			//		| dojo.query("#my-list").on("li:click", listener);
+			//		This will listen for click events within `<li>` elements that are inside the `#my-list` element.
+			//		Because on supports CSS selector syntax, we can use comma-delimited events as well:
+			//		| dojo.query("#my-list").on("li button:mouseover, li:click", listener);
+			var handles = this.map(function(node){
+				return on(node, eventName, listener); // TODO: apply to the NodeList so the same selector engine is used for matches
+			});
+			handles.remove = function(){
+				for(var i = 0; i < handles.length; i++){
+					handles[i].remove();
+				}
+			};
+			return handles;
+		},
+
+		end: function(){
+			// summary:
+			//		Ends use of the current `NodeList` by returning the previous NodeList
+			//		that generated the current NodeList.
+			// description:
+			//		Returns the `NodeList` that generated the current `NodeList`. If there
+			//		is no parent NodeList, an empty NodeList is returned.
+			// example:
+			//	|	dojo.query("a")
+			//	|		.filter(".disabled")
+			//	|			// operate on the anchors that only have a disabled class
+			//	|			.style("color", "grey")
+			//	|		.end()
+			//	|		// jump back to the list of anchors
+			//	|		.style(...)
+			//
+			if(this._parent){
+				return this._parent;
+			}else{
+				//Just return empty list.
+				return new this._NodeListCtor(0);
+			}
+		},
+
+		// http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array#Methods
+
+		// FIXME: handle return values for #3244
+		//		http://trac.dojotoolkit.org/ticket/3244
+
+		// FIXME:
+		//		need to wrap or implement:
+		//			join (perhaps w/ innerHTML/outerHTML overload for toString() of items?)
+		//			reduce
+		//			reduceRight
+
+		/*=====
+		slice: function(begin, end){
+			// summary:
+			//		Returns a new NodeList, maintaining this one in place
+			// description:
+			//		This method behaves exactly like the Array.slice method
+			//		with the caveat that it returns a dojo/NodeList and not a
+			//		raw Array. For more details, see Mozilla's [slice
+			//		documentation](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/slice)
+			// begin: Integer
+			//		Can be a positive or negative integer, with positive
+			//		integers noting the offset to begin at, and negative
+			//		integers denoting an offset from the end (i.e., to the left
+			//		of the end)
+			// end: Integer?
+			//		Optional parameter to describe what position relative to
+			//		the NodeList's zero index to end the slice at. Like begin,
+			//		can be positive or negative.
+			return this._wrap(a.slice.apply(this, arguments));
+		},
+
+		splice: function(index, howmany, item){
+			// summary:
+			//		Returns a new NodeList, manipulating this NodeList based on
+			//		the arguments passed, potentially splicing in new elements
+			//		at an offset, optionally deleting elements
+			// description:
+			//		This method behaves exactly like the Array.splice method
+			//		with the caveat that it returns a dojo/NodeList and not a
+			//		raw Array. For more details, see Mozilla's [splice
+			//		documentation](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/splice)
+			//		For backwards compatibility, calling .end() on the spliced NodeList
+			//		does not return the original NodeList -- splice alters the NodeList in place.
+			// index: Integer
+			//		begin can be a positive or negative integer, with positive
+			//		integers noting the offset to begin at, and negative
+			//		integers denoting an offset from the end (i.e., to the left
+			//		of the end)
+			// howmany: Integer?
+			//		Optional parameter to describe what position relative to
+			//		the NodeList's zero index to end the slice at. Like begin,
+			//		can be positive or negative.
+			// item: Object...?
+			//		Any number of optional parameters may be passed in to be
+			//		spliced into the NodeList
+			return this._wrap(a.splice.apply(this, arguments));	// dojo/NodeList
+		},
+
+		indexOf: function(value, fromIndex){
+			// summary:
+			//		see dojo.indexOf(). The primary difference is that the acted-on
+			//		array is implicitly this NodeList
+			// value: Object
+			//		The value to search for.
+			// fromIndex: Integer?
+			//		The location to start searching from. Optional. Defaults to 0.
+			// description:
+			//		For more details on the behavior of indexOf, see Mozilla's
+			//		[indexOf
+			//		docs](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/indexOf)
+			// returns:
+			//		Positive Integer or 0 for a match, -1 of not found.
+			return d.indexOf(this, value, fromIndex); // Integer
+		},
+
+		lastIndexOf: function(value, fromIndex){
+			// summary:
+			//		see dojo.lastIndexOf(). The primary difference is that the
+			//		acted-on array is implicitly this NodeList
+			// description:
+			//		For more details on the behavior of lastIndexOf, see
+			//		Mozilla's [lastIndexOf
+			//		docs](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/lastIndexOf)
+			// value: Object
+			//		The value to search for.
+			// fromIndex: Integer?
+			//		The location to start searching from. Optional. Defaults to 0.
+			// returns:
+			//		Positive Integer or 0 for a match, -1 of not found.
+			return d.lastIndexOf(this, value, fromIndex); // Integer
+		},
+
+		every: function(callback, thisObject){
+			// summary:
+			//		see `dojo.every()` and the [Array.every
+			//		docs](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/every).
+			//		Takes the same structure of arguments and returns as
+			//		dojo.every() with the caveat that the passed array is
+			//		implicitly this NodeList
+			// callback: Function
+			//		the callback
+			// thisObject: Object?
+			//		the context
+			return d.every(this, callback, thisObject); // Boolean
+		},
+
+		some: function(callback, thisObject){
+			// summary:
+			//		Takes the same structure of arguments and returns as
+			//		`dojo.some()` with the caveat that the passed array is
+			//		implicitly this NodeList.  See `dojo.some()` and Mozilla's
+			//		[Array.some
+			//		documentation](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/some).
+			// callback: Function
+			//		the callback
+			// thisObject: Object?
+			//		the context
+			return d.some(this, callback, thisObject); // Boolean
+		},
+		=====*/
+
+		concat: function(item){
+			// summary:
+			//		Returns a new NodeList comprised of items in this NodeList
+			//		as well as items passed in as parameters
+			// description:
+			//		This method behaves exactly like the Array.concat method
+			//		with the caveat that it returns a `NodeList` and not a
+			//		raw Array. For more details, see the [Array.concat
+			//		docs](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/concat)
+			// item: Object?
+			//		Any number of optional parameters may be passed in to be
+			//		spliced into the NodeList
+
+			//return this._wrap(apc.apply(this, arguments));
+			// the line above won't work for the native NodeList, or for Dojo NodeLists either :-(
+
+			// implementation notes:
+			// Array.concat() doesn't recognize native NodeLists or Dojo NodeLists
+			// as arrays, and so does not inline them into a unioned array, but
+			// appends them as single entities. Both the original NodeList and the
+			// items passed in as parameters must be converted to raw Arrays
+			// and then the concatenation result may be re-_wrap()ed as a Dojo NodeList.
+
+			var t = aps.call(this, 0),
+				m = array.map(arguments, function(a){
+					return aps.call(a, 0);
+				});
+			return this._wrap(apc.apply(t, m), this);	// dojo/NodeList
+		},
+
+		map: function(/*Function*/ func, /*Function?*/ obj){
+			// summary:
+			//		see dojo.map(). The primary difference is that the acted-on
+			//		array is implicitly this NodeList and the return is a
+			//		NodeList (a subclass of Array)
+			return this._wrap(array.map(this, func, obj), this); // dojo/NodeList
+		},
+
+		forEach: function(callback, thisObj){
+			// summary:
+			//		see `dojo.forEach()`. The primary difference is that the acted-on
+			//		array is implicitly this NodeList. If you want the option to break out
+			//		of the forEach loop, use every() or some() instead.
+			forEach(this, callback, thisObj);
+			// non-standard return to allow easier chaining
+			return this; // dojo/NodeList
+		},
+		filter: function(/*String|Function*/ filter){
+			// summary:
+			//		"masks" the built-in javascript filter() method (supported
+			//		in Dojo via `dojo.filter`) to support passing a simple
+			//		string filter in addition to supporting filtering function
+			//		objects.
+			// filter:
+			//		If a string, a CSS rule like ".thinger" or "div > span".
+			// example:
+			//		"regular" JS filter syntax as exposed in dojo.filter:
+			//		|	dojo.query("*").filter(function(item){
+			//		|		// highlight every paragraph
+			//		|		return (item.nodeName == "p");
+			//		|	}).style("backgroundColor", "yellow");
+			// example:
+			//		the same filtering using a CSS selector
+			//		|	dojo.query("*").filter("p").styles("backgroundColor", "yellow");
+
+			var a = arguments, items = this, start = 0;
+			if(typeof filter == "string"){ // inline'd type check
+				items = query._filterResult(this, a[0]);
+				if(a.length == 1){
+					// if we only got a string query, pass back the filtered results
+					return items._stash(this); // dojo/NodeList
+				}
+				// if we got a callback, run it over the filtered items
+				start = 1;
+			}
+			return this._wrap(array.filter(items, a[start], a[start + 1]), this);	// dojo/NodeList
+		},
+		instantiate: function(/*String|Object*/ declaredClass, /*Object?*/ properties){
+			// summary:
+			//		Create a new instance of a specified class, using the
+			//		specified properties and each node in the NodeList as a
+			//		srcNodeRef.
+			// example:
+			//		Grabs all buttons in the page and converts them to dijit/form/Button's.
+			//	|	var buttons = query("button").instantiate(Button, {showLabel: true});
+			var c = lang.isFunction(declaredClass) ? declaredClass : lang.getObject(declaredClass);
+			properties = properties || {};
+			return this.forEach(function(node){
+				new c(properties, node);
+			});	// dojo/NodeList
+		},
+		at: function(/*===== index =====*/){
+			// summary:
+			//		Returns a new NodeList comprised of items in this NodeList
+			//		at the given index or indices.
+			//
+			// index: Integer...
+			//		One or more 0-based indices of items in the current
+			//		NodeList. A negative index will start at the end of the
+			//		list and go backwards.
+			//
+			// example:
+			//	Shorten the list to the first, second, and third elements
+			//	|	query("a").at(0, 1, 2).forEach(fn);
+			//
+			// example:
+			//	Retrieve the first and last elements of a unordered list:
+			//	|	query("ul > li").at(0, -1).forEach(cb);
+			//
+			// example:
+			//	Do something for the first element only, but end() out back to
+			//	the original list and continue chaining:
+			//	|	query("a").at(0).onclick(fn).end().forEach(function(n){
+			//	|		console.log(n); // all anchors on the page.
+			//	|	})
+
+			var t = new this._NodeListCtor(0);
+			forEach(arguments, function(i){
+				if(i < 0){ i = this.length + i; }
+				if(this[i]){ t.push(this[i]); }
+			}, this);
+			return t._stash(this); // dojo/NodeList
+		}
+	});
+
+	function queryForEngine(engine, NodeList){
+		var query = function(/*String*/ query, /*String|DOMNode?*/ root){
+			// summary:
+			//		Returns nodes which match the given CSS selector, searching the
+			//		entire document by default but optionally taking a node to scope
+			//		the search by. Returns an instance of NodeList.
+			if(typeof root == "string"){
+				root = dom.byId(root);
+				if(!root){
+					return new NodeList([]);
+				}
+			}
+			var results = typeof query == "string" ? engine(query, root) : query ? (query.end && query.on) ? query : [query] : [];
+			if(results.end && results.on){
+				// already wrapped
+				return results;
+			}
+			return new NodeList(results);
+		};
+		query.matches = engine.match || function(node, selector, root){
+			// summary:
+			//		Test to see if a node matches a selector
+			return query.filter([node], selector, root).length > 0;
+		};
+		// the engine provides a filtering function, use it to for matching
+		query.filter = engine.filter || function(nodes, selector, root){
+			// summary:
+			//		Filters an array of nodes. Note that this does not guarantee to return a NodeList, just an array.
+			return query(selector, root).filter(function(node){
+				return array.indexOf(nodes, node) > -1;
+			});
+		};
+		if(typeof engine != "function"){
+			var search = engine.search;
+			engine = function(selector, root){
+				// Slick does it backwards (or everyone else does it backwards, probably the latter)
+				return search(root || document, selector);
+			};
+		}
+		return query;
+	}
+	var query = queryForEngine(defaultEngine, NodeList);
+	/*=====
+	query = function(selector, context){
+		// summary:
+		//		This modules provides DOM querying functionality. The module export is a function
+		//		that can be used to query for DOM nodes by CSS selector and returns a NodeList
+		//		representing the matching nodes.
+		// selector: String
+		//		A CSS selector to search for.
+		// context: String|DomNode?
+		//		An optional context to limit the searching scope. Only nodes under `context` will be
+		//		scanned.
+		// example:
+		//		add an onclick handler to every submit button in the document
+		//		which causes the form to be sent via Ajax instead:
+		//	|	require(["dojo/query"], function(query){
+		//	|		query("input[type='submit']").on("click", function(e){
+		//	|			dojo.stopEvent(e); // prevent sending the form
+		//	|			var btn = e.target;
+		//	|			dojo.xhrPost({
+		//	|				form: btn.form,
+		//	|				load: function(data){
+		//	|					// replace the form with the response
+		//	|					var div = dojo.doc.createElement("div");
+		//	|					dojo.place(div, btn.form, "after");
+		//	|					div.innerHTML = data;
+		//	|					dojo.style(btn.form, "display", "none");
+		//	|				}
+		//	|			});
+		//	|		});
+		// |	});
+		//
+		// description:
+		//		dojo/query is responsible for loading the appropriate query engine and wrapping
+		//		its results with a `NodeList`. You can use dojo/query with a specific selector engine
+		//		by using it as a plugin. For example, if you installed the sizzle package, you could
+		//		use it as the selector engine with:
+		//		|	require(["dojo/query!sizzle"], function(query){
+		//		|		query("div")...
+		//
+		//		The id after the ! can be a module id of the selector engine or one of the following values:
+		//
+		//		- acme: This is the default engine used by Dojo base, and will ensure that the full
+		//		Acme engine is always loaded.
+		//
+		//		- css2: If the browser has a native selector engine, this will be used, otherwise a
+		//		very minimal lightweight selector engine will be loaded that can do simple CSS2 selectors
+		//		(by #id, .class, tag, and [name=value] attributes, with standard child or descendant (>)
+		//		operators) and nothing more.
+		//
+		//		- css2.1: If the browser has a native selector engine, this will be used, otherwise the
+		//		full Acme engine will be loaded.
+		//
+		//		- css3: If the browser has a native selector engine with support for CSS3 pseudo
+		//		selectors (most modern browsers except IE8), this will be used, otherwise the
+		//		full Acme engine will be loaded.
+		//
+		//		- Or the module id of a selector engine can be used to explicitly choose the selector engine
+		//
+		//		For example, if you are using CSS3 pseudo selectors in module, you can specify that
+		//		you will need support them with:
+		//		|	require(["dojo/query!css3"], function(query){
+		//		|		query('#t > h3:nth-child(odd)')...
+		//
+		//		You can also choose the selector engine/load configuration by setting the query-selector:
+		//		For example:
+		//		|	<script data-dojo-config="query-selector:'css3'" src="dojo.js"></script>
+		//
+		return new NodeList(); // dojo/NodeList
+	 };
+	 =====*/
+
+	// the query that is returned from this module is slightly different than dojo.query,
+	// because dojo.query has to maintain backwards compatibility with returning a
+	// true array which has performance problems. The query returned from the module
+	// does not use true arrays, but rather inherits from Array, making it much faster to
+	// instantiate.
+	dojo.query = queryForEngine(defaultEngine, function(array){
+		// call it without the new operator to invoke the back-compat behavior that returns a true array
+		return NodeList(array);	// dojo/NodeList
+	});
+
+	query.load = function(id, parentRequire, loaded){
+		// summary:
+		//		can be used as AMD plugin to conditionally load new query engine
+		// example:
+		//	|	require(["dojo/query!custom"], function(qsa){
+		//	|		// loaded selector/custom.js as engine
+		//	|		qsa("#foobar").forEach(...);
+		//	|	});
+		loader.load(id, parentRequire, function(engine){
+			loaded(queryForEngine(engine, NodeList));
+		});
+	};
+
+	dojo._filterQueryResult = query._filterResult = function(nodes, selector, root){
+		return new NodeList(query.filter(nodes, selector, root));
+	};
+	dojo.NodeList = query.NodeList = NodeList;
+	return query;
+});

debian/missing-sources/dojo/ready.js

@@ -0,0 +1,153 @@
+define(["./_base/kernel", "./has", "require", "./has!host-browser?./domReady", "./_base/lang"], function(dojo, has, require, domReady, lang){
+	// module:
+	//		dojo/ready
+	// note:
+	//		This module should be unnecessary in dojo 2.0
+
+	var
+		// truthy if DOMContentLoaded or better (e.g., window.onload fired) has been achieved
+		isDomReady = 0,
+
+		// The queue of functions waiting to execute as soon as dojo.ready conditions satisfied
+		loadQ = [],
+
+		// prevent recursion in onLoad
+		onLoadRecursiveGuard = 0,
+
+		handleDomReady = function(){
+			isDomReady = 1;
+			dojo._postLoad = dojo.config.afterOnLoad = true;
+			onEvent();
+		},
+
+		onEvent = function(){
+			// Called when some state changes:
+			//		- dom ready
+			//		- dojo/domReady has finished processing everything in its queue
+			//		- task added to loadQ
+			//		- require() has finished loading all currently requested modules
+			//
+			// Run the functions queued with dojo.ready if appropriate.
+
+
+			//guard against recursions into this function
+			if(onLoadRecursiveGuard){
+				return;
+			}
+			onLoadRecursiveGuard = 1;
+
+			// Run tasks in queue if require() is finished loading modules, the dom is ready, and there are no
+			// pending tasks registered via domReady().
+			// The last step is necessary so that a user defined dojo.ready() callback is delayed until after the
+			// domReady() calls inside of dojo.	  Failure can be seen on dijit/tests/robot/Dialog_ally.html on IE8
+			// because the dijit/focus.js domReady() callback doesn't execute until after the test starts running.
+			while(isDomReady && (!domReady || domReady._Q.length == 0) && (require.idle ? require.idle() : true) && loadQ.length){
+				var f = loadQ.shift();
+				try{
+					f();
+				}catch(e){
+					// force the dojo.js on("error") handler do display the message
+					e.info = e.message;
+					if(require.signal){
+						require.signal("error", e);
+					}else{
+						throw e;
+					}
+				}
+			}
+
+			onLoadRecursiveGuard = 0;
+		};
+
+	// Check if we should run the next queue operation whenever require() finishes loading modules or domReady
+	// finishes processing it's queue.
+	require.on && require.on("idle", onEvent);
+	if(domReady){
+		domReady._onQEmpty = onEvent;
+	}
+
+	var ready = dojo.ready = dojo.addOnLoad = function(priority, context, callback){
+		// summary:
+		//		Add a function to execute on DOM content loaded and all requested modules have arrived and been evaluated.
+		//		In most cases, the `domReady` plug-in should suffice and this method should not be needed.
+		//
+		//		When called in a non-browser environment, just checks that all requested modules have arrived and been
+		//		evaluated.
+		// priority: Integer?
+		//		The order in which to exec this callback relative to other callbacks, defaults to 1000
+		// context: Object?|Function
+		//		The context in which to run execute callback, or a callback if not using context
+		// callback: Function?
+		//		The function to execute.
+		//
+		// example:
+		//	Simple DOM and Modules ready syntax
+		//	|	require(["dojo/ready"], function(ready){
+		//	|		ready(function(){ alert("Dom ready!"); });
+		//	|	});
+		//
+		// example:
+		//	Using a priority
+		//	|	require(["dojo/ready"], function(ready){
+		//	|		ready(2, function(){ alert("low priority ready!"); })
+		//	|	});
+		//
+		// example:
+		//	Using context
+		//	|	require(["dojo/ready"], function(ready){
+		//	|		ready(foo, function(){
+		//	|			// in here, this == foo
+		//	|		});
+		//	|	});
+		//
+		// example:
+		//	Using dojo/hitch style args:
+		//	|	require(["dojo/ready"], function(ready){
+		//	|		var foo = { dojoReady: function(){ console.warn(this, "dojo dom and modules ready."); } };
+		//	|		ready(foo, "dojoReady");
+		//	|	});
+
+		var hitchArgs = lang._toArray(arguments);
+		if(typeof priority != "number"){
+			callback = context;
+			context = priority;
+			priority = 1000;
+		}else{
+			hitchArgs.shift();
+		}
+		callback = callback ?
+			lang.hitch.apply(dojo, hitchArgs) :
+			function(){
+				context();
+			};
+		callback.priority = priority;
+		for(var i = 0; i < loadQ.length && priority >= loadQ[i].priority; i++){}
+		loadQ.splice(i, 0, callback);
+		onEvent();
+	};
+
+	has.add("dojo-config-addOnLoad", 1);
+	if(has("dojo-config-addOnLoad")){
+		var dca = dojo.config.addOnLoad;
+		if(dca){
+			ready[(lang.isArray(dca) ? "apply" : "call")](dojo, dca);
+		}
+	}
+
+	if(has("dojo-sync-loader") && dojo.config.parseOnLoad && !dojo.isAsync){
+		ready(99, function(){
+			if(!dojo.parser){
+				dojo.deprecated("Add explicit require(['dojo/parser']);", "", "2.0");
+				require(["dojo/parser"]);
+			}
+		});
+	}
+
+	if(domReady){
+		domReady(handleDomReady);
+	}else{
+		handleDomReady();
+	}
+
+	return ready;
+});

debian/missing-sources/dojo/router.js

@@ -0,0 +1,28 @@
+define([
+	"./router/RouterBase"
+], function(RouterBase){
+
+	// module:
+	//		dojo/router
+
+/*=====
+return {
+	// summary:
+	//		A singleton-style instance of dojo/router/RouterBase. See that
+	//		module for specifics.
+	// example:
+	//	|	router.register("/widgets/:id", function(evt){
+	//	|		// If "/widgets/3" was matched,
+	//	|		// evt.params.id === "3"
+	//	|		xhr.get({
+	//	|			url: "/some/path/" + evt.params.id,
+	//	|			load: function(data){
+	//	|				// ...
+	//	|			}
+	//	|		});
+	//	|	});
+};
+=====*/
+
+	return new RouterBase({});
+});

debian/missing-sources/dojo/router/RouterBase.js

@@ -0,0 +1,376 @@
+define([
+	"dojo/_base/declare",
+	"dojo/hash",
+	"dojo/topic"
+], function(declare, hash, topic){
+
+	// module:
+	//		dojo/router/RouterBase
+
+	// Creating a basic trim to avoid needing the full dojo/string module
+	// similarly to dojo/_base/lang's trim
+	var trim;
+	if(String.prototype.trim){
+		trim = function(str){ return str.trim(); };
+	}else{
+		trim = function(str){ return str.replace(/^\s\s*/, '').replace(/\s\s*$/, ''); };
+	}
+
+	// Firing of routes on the route object is always the same,
+	// no clean way to expose this on the prototype since it's for the
+	// internal router objects.
+	function fireRoute(params, currentPath, newPath){
+		var queue, isStopped, isPrevented, eventObj, callbackArgs, i, l;
+
+		queue = this.callbackQueue;
+		isStopped = false;
+		isPrevented = false;
+		eventObj = {
+			stopImmediatePropagation: function(){ isStopped = true; },
+			preventDefault: function(){ isPrevented = true; },
+			oldPath: currentPath,
+			newPath: newPath,
+			params: params
+		};
+
+		callbackArgs = [eventObj];
+
+		if(params instanceof Array){
+			callbackArgs = callbackArgs.concat(params);
+		}else{
+			for(var key in params){
+				callbackArgs.push(params[key]);
+			}
+		}
+
+		for(i=0, l=queue.length; i<l; ++i){
+			if(!isStopped){
+				queue[i].apply(null, callbackArgs);
+			}
+		}
+
+		return !isPrevented;
+	}
+
+	// Our actual class-like object
+	var RouterBase = declare(null, {
+		// summary:
+		//		A module that allows one to easily map hash-based structures into
+		//		callbacks. The router module is a singleton, offering one central
+		//		point for all registrations of this type.
+		// example:
+		//	|	var router = new RouterBase({});
+		//	|	router.register("/widgets/:id", function(evt){
+		//	|		// If "/widgets/3" was matched,
+		//	|		// evt.params.id === "3"
+		//	|		xhr.get({
+		//	|			url: "/some/path/" + evt.params.id,
+		//	|			load: function(data){
+		//	|				// ...
+		//	|			}
+		//	|		});
+		//	|	});
+
+		_routes: null,
+		_routeIndex: null,
+		_started: false,
+		_currentPath: "",
+
+		idMatch: /:(\w[\w\d]*)/g,
+		idReplacement: "([^\\/]+)",
+		globMatch: /\*(\w[\w\d]*)/,
+		globReplacement: "(.+)",
+
+		constructor: function(kwArgs){
+			// A couple of safety initializations
+			this._routes = [];
+			this._routeIndex = {};
+
+			// Simple constructor-style "Decorate myself all over" for now
+			for(var i in kwArgs){
+				if(kwArgs.hasOwnProperty(i)){
+					this[i] = kwArgs[i];
+				}
+			}
+		},
+
+		register: function(/*String|RegExp*/ route, /*Function*/ callback){
+			// summary:
+			//		Registers a route to a handling callback
+			// description:
+			//		Given either a string or a regular expression, the router
+			//		will monitor the page's hash and respond to changes that
+			//		match the string or regex as provided.
+			//
+			//		When provided a regex for the route:
+			//
+			//		- Matching is performed, and the resulting capture groups
+			//		are passed through to the callback as an array.
+			//
+			//		When provided a string for the route:
+			//
+			//		- The string is parsed as a URL-like structure, like
+			//		"/foo/bar"
+			//		- If any portions of that URL are prefixed with a colon
+			//		(:), they will be parsed out and provided to the callback
+			//		as properties of an object.
+			//		- If the last piece of the URL-like structure is prefixed
+			//		with a star (*) instead of a colon, it will be replaced in
+			//		the resulting regex with a greedy (.+) match and
+			//		anything remaining on the hash will be provided as a
+			//		property on the object passed into the callback. Think of
+			//		it like a basic means of globbing the end of a route.
+			// example:
+			//	|	router.register("/foo/:bar/*baz", function(object){
+			//	|		// If the hash was "/foo/abc/def/ghi",
+			//	|		// object.bar === "abc"
+			//	|		// object.baz === "def/ghi"
+			//	|	});
+			// returns: Object
+			//		A plain JavaScript object to be used as a handle for
+			//		either removing this specific callback's registration, as
+			//		well as to add new callbacks with the same route initially
+			//		used.
+			// route: String|RegExp
+			//		A string or regular expression which will be used when
+			//		monitoring hash changes.
+			// callback: Function
+			//		When the hash matches a pattern as described in the route,
+			//		this callback will be executed. It will receive an event
+			//		object that will have several properties:
+			//
+			//		- params: Either an array or object of properties pulled
+			//		from the new hash
+			//		- oldPath: The hash in its state before the change
+			//		- newPath: The new hash being shifted to
+			//		- preventDefault: A method that will stop hash changes
+			//		from being actually applied to the active hash. This only
+			//		works if the hash change was initiated using `router.go`,
+			//		as changes initiated more directly to the location.hash
+			//		property will already be in place
+			//		- stopImmediatePropagation: When called, will stop any
+			//		further bound callbacks on this particular route from
+			//		being executed. If two distinct routes are bound that are
+			//		different, but both happen to match the current hash in
+			//		some way, this will *not* keep other routes from receiving
+			//		notice of the change.
+
+			return this._registerRoute(route, callback);
+		},
+
+		registerBefore: function(/*String|RegExp*/ route, /*Function*/ callback){
+			// summary:
+			//		Registers a route to a handling callback, except before
+			//		any previously registered callbacks
+			// description:
+			//		Much like the `register` method, `registerBefore` allows
+			//		us to register route callbacks to happen before any
+			//		previously registered callbacks. See the documentation for
+			//		`register` for more details and examples.
+
+			return this._registerRoute(route, callback, true);
+		},
+
+		go: function(path, replace){
+			// summary:
+			//		A simple pass-through to make changing the hash easy,
+			//		without having to require dojo/hash directly. It also
+			//		synchronously fires off any routes that match.
+			// example:
+			//	|	router.go("/foo/bar");
+
+			var applyChange;
+
+			if(typeof path !== "string"){return false;}
+
+			path = trim(path);
+			applyChange = this._handlePathChange(path);
+
+			if(applyChange){
+				hash(path, replace);
+			}
+
+			return applyChange;
+		},
+
+		startup: function(defaultPath){
+			// summary:
+			//		This method must be called to activate the router. Until
+			//		startup is called, no hash changes will trigger route
+			//		callbacks.
+
+			if(this._started){ return; }
+
+			var self = this,
+				startingPath = hash();
+
+			this._started = true;
+			this._hashchangeHandle = topic.subscribe("/dojo/hashchange", function(){
+				self._handlePathChange.apply(self, arguments);
+			});
+
+			if(!startingPath){
+				// If there is no initial starting point, push our defaultPath into our
+				// history as the starting point
+				this.go(defaultPath, true);
+			}else{
+				// Handle the starting path
+				this._handlePathChange(startingPath);
+			}
+		},
+
+		destroy: function(){
+			this._hashchangeHandle.remove();
+			this._routes = null;
+			this._routeIndex = null;
+		},
+
+		_handlePathChange: function(newPath){
+			var i, j, li, lj, routeObj, result,
+				allowChange, parameterNames, params,
+				routes = this._routes,
+				currentPath = this._currentPath;
+
+			if(!this._started || newPath === currentPath){ return allowChange; }
+
+			allowChange = true;
+
+			for(i=0, li=routes.length; i<li; ++i){
+				routeObj = routes[i];
+				result = routeObj.route.exec(newPath);
+
+				if(result){
+					if(routeObj.parameterNames){
+						parameterNames = routeObj.parameterNames;
+						params = {};
+
+						for(j=0, lj=parameterNames.length; j<lj; ++j){
+							params[parameterNames[j]] = result[j+1];
+						}
+					}else{
+						params = result.slice(1);
+					}
+					allowChange = routeObj.fire(params, currentPath, newPath);
+				}
+			}
+
+			if(allowChange){
+				this._currentPath = newPath;
+			}
+
+			return allowChange;
+		},
+
+		_convertRouteToRegExp: function(route){
+			// Sub in based on IDs and globs
+			route = route.replace(this.idMatch, this.idReplacement);
+			route = route.replace(this.globMatch, this.globReplacement);
+			// Make sure it's an exact match
+			route = "^" + route + "$";
+
+			return new RegExp(route);
+		},
+
+		_getParameterNames: function(route){
+			var idMatch = this.idMatch,
+				globMatch = this.globMatch,
+				parameterNames = [], match;
+
+			idMatch.lastIndex = 0;
+
+			while((match = idMatch.exec(route)) !== null){
+				parameterNames.push(match[1]);
+			}
+			if((match = globMatch.exec(route)) !== null){
+				parameterNames.push(match[1]);
+			}
+
+			return parameterNames.length > 0 ? parameterNames : null;
+		},
+
+		_indexRoutes: function(){
+			var i, l, route, routeIndex, routes = this._routes;
+
+			// Start a new route index
+			routeIndex = this._routeIndex = {};
+
+			// Set it up again
+			for(i=0, l=routes.length; i<l; ++i){
+				route = routes[i];
+				routeIndex[route.route] = i;
+			}
+		},
+
+		_registerRoute: function(/*String|RegExp*/route, /*Function*/callback, /*Boolean?*/isBefore){
+			var index, exists, routeObj, callbackQueue, removed,
+				self = this, routes = this._routes,
+				routeIndex = this._routeIndex;
+
+			// Try to fetch the route if it already exists.
+			// This works thanks to stringifying of regex
+			index = this._routeIndex[route];
+			exists = typeof index !== "undefined";
+			if(exists){
+				routeObj = routes[index];
+			}
+
+			// If we didn't get one, make a default start point
+			if(!routeObj){
+				routeObj = {
+					route: route,
+					callbackQueue: [],
+					fire: fireRoute
+				};
+			}
+
+			callbackQueue = routeObj.callbackQueue;
+
+			if(typeof route == "string"){
+				routeObj.parameterNames = this._getParameterNames(route);
+				routeObj.route = this._convertRouteToRegExp(route);
+			}
+
+			if(isBefore){
+				callbackQueue.unshift(callback);
+			}else{
+				callbackQueue.push(callback);
+			}
+
+			if(!exists){
+				index = routes.length;
+				routeIndex[route] = index;
+				routes.push(routeObj);
+			}
+
+			// Useful in a moment to keep from re-removing routes
+			removed = false;
+
+			return { // Object
+				remove: function(){
+					var i, l;
+
+					if(removed){ return; }
+
+					for(i=0, l=callbackQueue.length; i<l; ++i){
+						if(callbackQueue[i] === callback){
+							callbackQueue.splice(i, 1);
+						}
+					}
+
+
+					if(callbackQueue.length === 0){
+						routes.splice(index, 1);
+						self._indexRoutes();
+					}
+
+					removed = true;
+				},
+				register: function(callback, isBefore){
+					return self.register(route, callback, isBefore);
+				}
+			};
+		}
+	});
+
+	return RouterBase;
+});

debian/missing-sources/dojo/sniff.js

@@ -0,0 +1,80 @@
+define(["./has"], function(has){
+	// module:
+	//		dojo/sniff
+
+	/*=====
+	return function(){
+		// summary:
+		//		This module sets has() flags based on the current browser.
+		//		It returns the has() function.
+	};
+	=====*/
+
+	if(has("host-browser")){
+		var n = navigator,
+			dua = n.userAgent,
+			dav = n.appVersion,
+			tv = parseFloat(dav);
+
+		has.add("air", dua.indexOf("AdobeAIR") >= 0);
+		has.add("msapp", parseFloat(dua.split("MSAppHost/")[1]) || undefined);
+		has.add("khtml", dav.indexOf("Konqueror") >= 0 ? tv : undefined);
+		has.add("webkit", parseFloat(dua.split("WebKit/")[1]) || undefined);
+		has.add("chrome", parseFloat(dua.split("Chrome/")[1]) || undefined);
+		has.add("safari", dav.indexOf("Safari")>=0 && !has("chrome") ? parseFloat(dav.split("Version/")[1]) : undefined);
+		has.add("mac", dav.indexOf("Macintosh") >= 0);
+		has.add("quirks", document.compatMode == "BackCompat");
+		if(dua.match(/(iPhone|iPod|iPad)/)){
+			var p = RegExp.$1.replace(/P/, "p");
+			var v = dua.match(/OS ([\d_]+)/) ? RegExp.$1 : "1";
+			var os = parseFloat(v.replace(/_/, ".").replace(/_/g, ""));
+			has.add(p, os);		// "iphone", "ipad" or "ipod"
+			has.add("ios", os);
+		}
+		has.add("android", parseFloat(dua.split("Android ")[1]) || undefined);
+		has.add("bb", (dua.indexOf("BlackBerry") >= 0 || dua.indexOf("BB10") >= 0) && parseFloat(dua.split("Version/")[1]) || undefined);
+
+		has.add("svg", typeof SVGAngle !== "undefined");
+
+		if(!has("webkit")){
+			// Opera
+			if(dua.indexOf("Opera") >= 0){
+				// see http://dev.opera.com/articles/view/opera-ua-string-changes and http://www.useragentstring.com/pages/Opera/
+				// 9.8 has both styles; <9.8, 9.9 only old style
+				has.add("opera", tv >= 9.8 ? parseFloat(dua.split("Version/")[1]) || tv : tv);
+			}
+
+			// Mozilla and firefox
+			if(dua.indexOf("Gecko") >= 0 && !has("khtml") && !has("webkit")){
+				has.add("mozilla", tv);
+			}
+			if(has("mozilla")){
+				//We really need to get away from this. Consider a sane isGecko approach for the future.
+				has.add("ff", parseFloat(dua.split("Firefox/")[1] || dua.split("Minefield/")[1]) || undefined);
+			}
+
+			// IE
+			if(document.all && !has("opera")){
+				var isIE = parseFloat(dav.split("MSIE ")[1]) || undefined;
+
+				//In cases where the page has an HTTP header or META tag with
+				//X-UA-Compatible, then it is in emulation mode.
+				//Make sure isIE reflects the desired version.
+				//document.documentMode of 5 means quirks mode.
+				//Only switch the value if documentMode's major version
+				//is different from isIE's major version.
+				var mode = document.documentMode;
+				if(mode && mode != 5 && Math.floor(isIE) != mode){
+					isIE = mode;
+				}
+
+				has.add("ie", isIE);
+			}
+
+			// Wii
+			has.add("wii", typeof opera != "undefined" && opera.wiiremote);
+		}
+	}
+
+	return has;
+});

debian/missing-sources/dojo/store/Memory.js

@@ -0,0 +1,164 @@
+define(["../_base/declare", "./util/QueryResults", "./util/SimpleQueryEngine" /*=====, "./api/Store" =====*/],
+function(declare, QueryResults, SimpleQueryEngine /*=====, Store =====*/){
+
+// module:
+//		dojo/store/Memory
+
+// No base class, but for purposes of documentation, the base class is dojo/store/api/Store
+var base = null;
+/*===== base = Store; =====*/
+
+return declare("dojo.store.Memory", base, {
+	// summary:
+	//		This is a basic in-memory object store. It implements dojo/store/api/Store.
+	constructor: function(options){
+		// summary:
+		//		Creates a memory object store.
+		// options: dojo/store/Memory
+		//		This provides any configuration information that will be mixed into the store.
+		//		This should generally include the data property to provide the starting set of data.
+		for(var i in options){
+			this[i] = options[i];
+		}
+		this.setData(this.data || []);
+	},
+	// data: Array
+	//		The array of all the objects in the memory store
+	data:null,
+
+	// idProperty: String
+	//		Indicates the property to use as the identity property. The values of this
+	//		property should be unique.
+	idProperty: "id",
+
+	// index: Object
+	//		An index of data indices into the data array by id
+	index:null,
+
+	// queryEngine: Function
+	//		Defines the query engine to use for querying the data store
+	queryEngine: SimpleQueryEngine,
+	get: function(id){
+		// summary:
+		//		Retrieves an object by its identity
+		// id: Number
+		//		The identity to use to lookup the object
+		// returns: Object
+		//		The object in the store that matches the given id.
+		return this.data[this.index[id]];
+	},
+	getIdentity: function(object){
+		// summary:
+		//		Returns an object's identity
+		// object: Object
+		//		The object to get the identity from
+		// returns: Number
+		return object[this.idProperty];
+	},
+	put: function(object, options){
+		// summary:
+		//		Stores an object
+		// object: Object
+		//		The object to store.
+		// options: dojo/store/api/Store.PutDirectives?
+		//		Additional metadata for storing the data.  Includes an "id"
+		//		property if a specific id is to be used.
+		// returns: Number
+		var data = this.data,
+			index = this.index,
+			idProperty = this.idProperty;
+		var id = object[idProperty] = (options && "id" in options) ? options.id : idProperty in object ? object[idProperty] : Math.random();
+		if(id in index){
+			// object exists
+			if(options && options.overwrite === false){
+				throw new Error("Object already exists");
+			}
+			// replace the entry in data
+			data[index[id]] = object;
+		}else{
+			// add the new object
+			index[id] = data.push(object) - 1;
+		}
+		return id;
+	},
+	add: function(object, options){
+		// summary:
+		//		Creates an object, throws an error if the object already exists
+		// object: Object
+		//		The object to store.
+		// options: dojo/store/api/Store.PutDirectives?
+		//		Additional metadata for storing the data.  Includes an "id"
+		//		property if a specific id is to be used.
+		// returns: Number
+		(options = options || {}).overwrite = false;
+		// call put with overwrite being false
+		return this.put(object, options);
+	},
+	remove: function(id){
+		// summary:
+		//		Deletes an object by its identity
+		// id: Number
+		//		The identity to use to delete the object
+		// returns: Boolean
+		//		Returns true if an object was removed, falsy (undefined) if no object matched the id
+		var index = this.index;
+		var data = this.data;
+		if(id in index){
+			data.splice(index[id], 1);
+			// now we have to reindex
+			this.setData(data);
+			return true;
+		}
+	},
+	query: function(query, options){
+		// summary:
+		//		Queries the store for objects.
+		// query: Object
+		//		The query to use for retrieving objects from the store.
+		// options: dojo/store/api/Store.QueryOptions?
+		//		The optional arguments to apply to the resultset.
+		// returns: dojo/store/api/Store.QueryResults
+		//		The results of the query, extended with iterative methods.
+		//
+		// example:
+		//		Given the following store:
+		//
+		// 	|	var store = new Memory({
+		// 	|		data: [
+		// 	|			{id: 1, name: "one", prime: false },
+		//	|			{id: 2, name: "two", even: true, prime: true},
+		//	|			{id: 3, name: "three", prime: true},
+		//	|			{id: 4, name: "four", even: true, prime: false},
+		//	|			{id: 5, name: "five", prime: true}
+		//	|		]
+		//	|	});
+		//
+		//	...find all items where "prime" is true:
+		//
+		//	|	var results = store.query({ prime: true });
+		//
+		//	...or find all items where "even" is true:
+		//
+		//	|	var results = store.query({ even: true });
+		return QueryResults(this.queryEngine(query, options)(this.data));
+	},
+	setData: function(data){
+		// summary:
+		//		Sets the given data as the source for this store, and indexes it
+		// data: Object[]
+		//		An array of objects to use as the source of data.
+		if(data.items){
+			// just for convenience with the data format IFRS expects
+			this.idProperty = data.identifier;
+			data = this.data = data.items;
+		}else{
+			this.data = data;
+		}
+		this.index = {};
+		for(var i = 0, l = data.length; i < l; i++){
+			this.index[data[i][this.idProperty]] = i;
+		}
+	}
+});
+
+});

debian/missing-sources/dojo/store/Observable.js

@@ -0,0 +1,187 @@
+define(["../_base/kernel", "../_base/lang", "../when", "../_base/array" /*=====, "./api/Store" =====*/
+], function(kernel, lang, when, array /*=====, Store =====*/){
+
+// module:
+//		dojo/store/Observable
+
+var Observable = function(/*Store*/ store){
+	// summary:
+	//		The Observable store wrapper takes a store and sets an observe method on query()
+	//		results that can be used to monitor results for changes.
+	//
+	// description:
+	//		Observable wraps an existing store so that notifications can be made when a query
+	//		is performed.
+	//
+	// example:
+	//		Create a Memory store that returns an observable query, and then log some
+	//		information about that query.
+	//
+	//	|	var store = Observable(new Memory({
+	//	|		data: [
+	//	|			{id: 1, name: "one", prime: false},
+	//	|			{id: 2, name: "two", even: true, prime: true},
+	//	|			{id: 3, name: "three", prime: true},
+	//	|			{id: 4, name: "four", even: true, prime: false},
+	//	|			{id: 5, name: "five", prime: true}
+	//	|		]
+	//	|	}));
+	//	|	var changes = [], results = store.query({ prime: true });
+	//	|	var observer = results.observe(function(object, previousIndex, newIndex){
+	//	|		changes.push({previousIndex:previousIndex, newIndex:newIndex, object:object});
+	//	|	});
+	//
+	//		See the Observable tests for more information.
+
+	var undef, queryUpdaters = [], revision = 0;
+	// a Comet driven store could directly call notify to notify observers when data has
+	// changed on the backend
+	// create a new instance
+	store = lang.delegate(store);
+	
+	store.notify = function(object, existingId){
+		revision++;
+		var updaters = queryUpdaters.slice();
+		for(var i = 0, l = updaters.length; i < l; i++){
+			updaters[i](object, existingId);
+		}
+	};
+	var originalQuery = store.query;
+	store.query = function(query, options){
+		options = options || {};
+		var results = originalQuery.apply(this, arguments);
+		if(results && results.forEach){
+			var nonPagedOptions = lang.mixin({}, options);
+			delete nonPagedOptions.start;
+			delete nonPagedOptions.count;
+
+			var queryExecutor = store.queryEngine && store.queryEngine(query, nonPagedOptions);
+			var queryRevision = revision;
+			var listeners = [], queryUpdater;
+			results.observe = function(listener, includeObjectUpdates){
+				if(listeners.push(listener) == 1){
+					// first listener was added, create the query checker and updater
+					queryUpdaters.push(queryUpdater = function(changed, existingId){
+						when(results, function(resultsArray){
+							var atEnd = resultsArray.length != options.count;
+							var i, l, listener;
+							if(++queryRevision != revision){
+								throw new Error("Query is out of date, you must observe() the query prior to any data modifications");
+							}
+							var removedObject, removedFrom = -1, insertedInto = -1;
+							if(existingId !== undef){
+								// remove the old one
+								for(i = 0, l = resultsArray.length; i < l; i++){
+									var object = resultsArray[i];
+									if(store.getIdentity(object) == existingId){
+										removedObject = object;
+										removedFrom = i;
+										if(queryExecutor || !changed){// if it was changed and we don't have a queryExecutor, we shouldn't remove it because updated objects would be eliminated
+											resultsArray.splice(i, 1);
+										}
+										break;
+									}
+								}
+							}
+							if(queryExecutor){
+								// add the new one
+								if(changed &&
+										// if a matches function exists, use that (probably more efficient)
+										(queryExecutor.matches ? queryExecutor.matches(changed) : queryExecutor([changed]).length)){
+
+									var firstInsertedInto = removedFrom > -1 ? 
+										removedFrom : // put back in the original slot so it doesn't move unless it needs to (relying on a stable sort below)
+										resultsArray.length;
+									resultsArray.splice(firstInsertedInto, 0, changed); // add the new item
+									insertedInto = array.indexOf(queryExecutor(resultsArray), changed); // sort it
+									// we now need to push the chagne back into the original results array
+									resultsArray.splice(firstInsertedInto, 1); // remove the inserted item from the previous index
+									
+									if((options.start && insertedInto == 0) ||
+										(!atEnd && insertedInto == resultsArray.length)){
+										// if it is at the end of the page, assume it goes into the prev or next page
+										insertedInto = -1;
+									}else{
+										resultsArray.splice(insertedInto, 0, changed); // and insert into the results array with the correct index
+									}
+								}
+							}else if(changed){
+								// we don't have a queryEngine, so we can't provide any information
+								// about where it was inserted or moved to. If it is an update, we leave it's position alone, other we at least indicate a new object
+								if(existingId !== undef){
+									// an update, keep the index the same
+									insertedInto = removedFrom;
+								}else if(!options.start){
+									// a new object
+									insertedInto = store.defaultIndex || 0;
+									resultsArray.splice(insertedInto, 0, changed);
+								}
+							}
+							if((removedFrom > -1 || insertedInto > -1) &&
+									(includeObjectUpdates || !queryExecutor || (removedFrom != insertedInto))){
+								var copyListeners = listeners.slice();
+								for(i = 0;listener = copyListeners[i]; i++){
+									listener(changed || removedObject, removedFrom, insertedInto);
+								}
+							}
+						});
+					});
+				}
+				var handle = {};
+				// TODO: Remove cancel in 2.0.
+				handle.remove = handle.cancel = function(){
+					// remove this listener
+					var index = array.indexOf(listeners, listener);
+					if(index > -1){ // check to make sure we haven't already called cancel
+						listeners.splice(index, 1);
+						if(!listeners.length){
+							// no more listeners, remove the query updater too
+							queryUpdaters.splice(array.indexOf(queryUpdaters, queryUpdater), 1);
+						}
+					}
+				};
+				return handle;
+			};
+		}
+		return results;
+	};
+	var inMethod;
+	function whenFinished(method, action){
+		var original = store[method];
+		if(original){
+			store[method] = function(value){
+				if(inMethod){
+					// if one method calls another (like add() calling put()) we don't want two events
+					return original.apply(this, arguments);
+				}
+				inMethod = true;
+				try{
+					var results = original.apply(this, arguments);
+					when(results, function(results){
+						action((typeof results == "object" && results) || value);
+					});
+					return results;
+				}finally{
+					inMethod = false;
+				}
+			};
+		}
+	}
+	// monitor for updates by listening to these methods
+	whenFinished("put", function(object){
+		store.notify(object, store.getIdentity(object));
+	});
+	whenFinished("add", function(object){
+		store.notify(object);
+	});
+	whenFinished("remove", function(id){
+		store.notify(undefined, id);
+	});
+
+	return store;
+};
+
+lang.setObject("dojo.store.Observable", Observable);
+
+return Observable;
+});

debian/missing-sources/dojo/store/util/QueryResults.js

@@ -0,0 +1,63 @@
+define(["../../_base/array", "../../_base/lang", "../../when"
+], function(array, lang, when){
+
+// module:
+//		dojo/store/util/QueryResults
+
+var QueryResults = function(results){
+	// summary:
+	//		A function that wraps the results of a store query with additional
+	//		methods.
+	// description:
+	//		QueryResults is a basic wrapper that allows for array-like iteration
+	//		over any kind of returned data from a query.  While the simplest store
+	//		will return a plain array of data, other stores may return deferreds or
+	//		promises; this wrapper makes sure that *all* results can be treated
+	//		the same.
+	//
+	//		Additional methods include `forEach`, `filter` and `map`.
+	// results: Array|dojo/promise/Promise
+	//		The result set as an array, or a promise for an array.
+	// returns:
+	//		An array-like object that can be used for iterating over.
+	// example:
+	//		Query a store and iterate over the results.
+	//
+	//	|	store.query({ prime: true }).forEach(function(item){
+	//	|		//	do something
+	//	|	});
+
+	if(!results){
+		return results;
+	}
+	// if it is a promise it may be frozen
+	if(results.then){
+		results = lang.delegate(results);
+	}
+	function addIterativeMethod(method){
+		if(!results[method]){
+			results[method] = function(){
+				var args = arguments;
+				return when(results, function(results){
+					Array.prototype.unshift.call(args, results);
+					return QueryResults(array[method].apply(array, args));
+				});
+			};
+		}
+	}
+	addIterativeMethod("forEach");
+	addIterativeMethod("filter");
+	addIterativeMethod("map");
+	if(!results.total){
+		results.total = when(results, function(results){
+			return results.length;
+		});
+	}
+	return results; // Object
+};
+
+lang.setObject("dojo.store.util.QueryResults", QueryResults);
+
+return QueryResults;
+
+});

debian/missing-sources/dojo/store/util/SimpleQueryEngine.js

@@ -0,0 +1,110 @@
+define(["../../_base/array" /*=====, "../api/Store" =====*/], function(arrayUtil /*=====, Store =====*/){
+
+// module:
+//		dojo/store/util/SimpleQueryEngine
+
+return function(query, options){
+	// summary:
+	//		Simple query engine that matches using filter functions, named filter
+	//		functions or objects by name-value on a query object hash
+	//
+	// description:
+	//		The SimpleQueryEngine provides a way of getting a QueryResults through
+	//		the use of a simple object hash as a filter.  The hash will be used to
+	//		match properties on data objects with the corresponding value given. In
+	//		other words, only exact matches will be returned.
+	//
+	//		This function can be used as a template for more complex query engines;
+	//		for example, an engine can be created that accepts an object hash that
+	//		contains filtering functions, or a string that gets evaluated, etc.
+	//
+	//		When creating a new dojo.store, simply set the store's queryEngine
+	//		field as a reference to this function.
+	//
+	// query: Object
+	//		An object hash with fields that may match fields of items in the store.
+	//		Values in the hash will be compared by normal == operator, but regular expressions
+	//		or any object that provides a test() method are also supported and can be
+	//		used to match strings by more complex expressions
+	//		(and then the regex's or object's test() method will be used to match values).
+	//
+	// options: dojo/store/api/Store.QueryOptions?
+	//		An object that contains optional information such as sort, start, and count.
+	//
+	// returns: Function
+	//		A function that caches the passed query under the field "matches".  See any
+	//		of the "query" methods on dojo.stores.
+	//
+	// example:
+	//		Define a store with a reference to this engine, and set up a query method.
+	//
+	//	|	var myStore = function(options){
+	//	|		//	...more properties here
+	//	|		this.queryEngine = SimpleQueryEngine;
+	//	|		//	define our query method
+	//	|		this.query = function(query, options){
+	//	|			return QueryResults(this.queryEngine(query, options)(this.data));
+	//	|		};
+	//	|	};
+
+	// create our matching query function
+	switch(typeof query){
+		default:
+			throw new Error("Can not query with a " + typeof query);
+		case "object": case "undefined":
+			var queryObject = query;
+			query = function(object){
+				for(var key in queryObject){
+					var required = queryObject[key];
+					if(required && required.test){
+						// an object can provide a test method, which makes it work with regex
+						if(!required.test(object[key], object)){
+							return false;
+						}
+					}else if(required != object[key]){
+						return false;
+					}
+				}
+				return true;
+			};
+			break;
+		case "string":
+			// named query
+			if(!this[query]){
+				throw new Error("No filter function " + query + " was found in store");
+			}
+			query = this[query];
+			// fall through
+		case "function":
+			// fall through
+	}
+	function execute(array){
+		// execute the whole query, first we filter
+		var results = arrayUtil.filter(array, query);
+		// next we sort
+		var sortSet = options && options.sort;
+		if(sortSet){
+			results.sort(typeof sortSet == "function" ? sortSet : function(a, b){
+				for(var sort, i=0; sort = sortSet[i]; i++){
+					var aValue = a[sort.attribute];
+					var bValue = b[sort.attribute];
+					if (aValue != bValue){
+						return !!sort.descending == (aValue == null || aValue > bValue) ? -1 : 1;
+					}
+				}
+				return 0;
+			});
+		}
+		// now we paginate
+		if(options && (options.start || options.count)){
+			var total = results.length;
+			results = results.slice(options.start || 0, (options.start || 0) + (options.count || Infinity));
+			results.total = total;
+		}
+		return results;
+	}
+	execute.matches = query;
+	return execute;
+};
+
+});

debian/missing-sources/dojo/string.js

@@ -0,0 +1,162 @@
+define([
+	"./_base/kernel",	// kernel.global
+	"./_base/lang"
+], function(kernel, lang){
+
+// module:
+//		dojo/string
+
+var string = {
+	// summary:
+	//		String utilities for Dojo
+};
+lang.setObject("dojo.string", string);
+
+string.rep = function(/*String*/str, /*Integer*/num){
+	// summary:
+	//		Efficiently replicate a string `n` times.
+	// str:
+	//		the string to replicate
+	// num:
+	//		number of times to replicate the string
+
+	if(num <= 0 || !str){ return ""; }
+
+	var buf = [];
+	for(;;){
+		if(num & 1){
+			buf.push(str);
+		}
+		if(!(num >>= 1)){ break; }
+		str += str;
+	}
+	return buf.join("");	// String
+};
+
+string.pad = function(/*String*/text, /*Integer*/size, /*String?*/ch, /*Boolean?*/end){
+	// summary:
+	//		Pad a string to guarantee that it is at least `size` length by
+	//		filling with the character `ch` at either the start or end of the
+	//		string. Pads at the start, by default.
+	// text:
+	//		the string to pad
+	// size:
+	//		length to provide padding
+	// ch:
+	//		character to pad, defaults to '0'
+	// end:
+	//		adds padding at the end if true, otherwise pads at start
+	// example:
+	//	|	// Fill the string to length 10 with "+" characters on the right.  Yields "Dojo++++++".
+	//	|	string.pad("Dojo", 10, "+", true);
+
+	if(!ch){
+		ch = '0';
+	}
+	var out = String(text),
+		pad = string.rep(ch, Math.ceil((size - out.length) / ch.length));
+	return end ? out + pad : pad + out;	// String
+};
+
+string.substitute = function(	/*String*/		template,
+									/*Object|Array*/map,
+									/*Function?*/	transform,
+									/*Object?*/		thisObject){
+	// summary:
+	//		Performs parameterized substitutions on a string. Throws an
+	//		exception if any parameter is unmatched.
+	// template:
+	//		a string with expressions in the form `${key}` to be replaced or
+	//		`${key:format}` which specifies a format function. keys are case-sensitive.
+	// map:
+	//		hash to search for substitutions
+	// transform:
+	//		a function to process all parameters before substitution takes
+	//		place, e.g. mylib.encodeXML
+	// thisObject:
+	//		where to look for optional format function; default to the global
+	//		namespace
+	// example:
+	//		Substitutes two expressions in a string from an Array or Object
+	//	|	// returns "File 'foo.html' is not found in directory '/temp'."
+	//	|	// by providing substitution data in an Array
+	//	|	string.substitute(
+	//	|		"File '${0}' is not found in directory '${1}'.",
+	//	|		["foo.html","/temp"]
+	//	|	);
+	//	|
+	//	|	// also returns "File 'foo.html' is not found in directory '/temp'."
+	//	|	// but provides substitution data in an Object structure.  Dotted
+	//	|	// notation may be used to traverse the structure.
+	//	|	string.substitute(
+	//	|		"File '${name}' is not found in directory '${info.dir}'.",
+	//	|		{ name: "foo.html", info: { dir: "/temp" } }
+	//	|	);
+	// example:
+	//		Use a transform function to modify the values:
+	//	|	// returns "file 'foo.html' is not found in directory '/temp'."
+	//	|	string.substitute(
+	//	|		"${0} is not found in ${1}.",
+	//	|		["foo.html","/temp"],
+	//	|		function(str){
+	//	|			// try to figure out the type
+	//	|			var prefix = (str.charAt(0) == "/") ? "directory": "file";
+	//	|			return prefix + " '" + str + "'";
+	//	|		}
+	//	|	);
+	// example:
+	//		Use a formatter
+	//	|	// returns "thinger -- howdy"
+	//	|	string.substitute(
+	//	|		"${0:postfix}", ["thinger"], null, {
+	//	|			postfix: function(value, key){
+	//	|				return value + " -- howdy";
+	//	|			}
+	//	|		}
+	//	|	);
+
+	thisObject = thisObject || kernel.global;
+	transform = transform ?
+		lang.hitch(thisObject, transform) : function(v){ return v; };
+
+	return template.replace(/\$\{([^\s\:\}]+)(?:\:([^\s\:\}]+))?\}/g,
+		function(match, key, format){
+			var value = lang.getObject(key, false, map);
+			if(format){
+				value = lang.getObject(format, false, thisObject).call(thisObject, value, key);
+			}
+			return transform(value, key).toString();
+		}); // String
+};
+
+string.trim = String.prototype.trim ?
+	lang.trim : // aliasing to the native function
+	function(str){
+		str = str.replace(/^\s+/, '');
+		for(var i = str.length - 1; i >= 0; i--){
+			if(/\S/.test(str.charAt(i))){
+				str = str.substring(0, i + 1);
+				break;
+			}
+		}
+		return str;
+	};
+
+/*=====
+ string.trim = function(str){
+	 // summary:
+	 //		Trims whitespace from both sides of the string
+	 // str: String
+	 //		String to be trimmed
+	 // returns: String
+	 //		Returns the trimmed string
+	 // description:
+	 //		This version of trim() was taken from [Steven Levithan's blog](http://blog.stevenlevithan.com/archives/faster-trim-javascript).
+	 //		The short yet performant version of this function is dojo.trim(),
+	 //		which is part of Dojo base.  Uses String.prototype.trim instead, if available.
+	 return "";	// String
+ };
+ =====*/
+
+	return string;
+});

debian/missing-sources/dojo/topic.js

@@ -0,0 +1,38 @@
+define(["./Evented"], function(Evented){
+
+	// module:
+	//		dojo/topic
+
+	var hub = new Evented;
+	return {
+		// summary:
+		//		Pubsub hub.
+		// example:
+		//		| 	topic.subscribe("some/topic", function(event){
+		//		|	... do something with event
+		//		|	});
+		//		|	topic.publish("some/topic", {name:"some event", ...});
+
+		publish: function(topic, event){
+			// summary:
+			//		Publishes a message to a topic on the pub/sub hub. All arguments after
+			//		the first will be passed to the subscribers, so any number of arguments
+			//		can be provided (not just event).
+			// topic: String
+			//		The name of the topic to publish to
+			// event: Object
+			//		An event to distribute to the topic listeners
+			return hub.emit.apply(hub, arguments);
+		},
+
+		subscribe: function(topic, listener){
+			// summary:
+			//		Subscribes to a topic on the pub/sub hub
+			// topic: String
+			//		The topic to subscribe to
+			// listener: Function
+			//		A function to call when a message is published to the given topic
+			return hub.on.apply(hub, arguments);
+		}
+	};
+});

debian/missing-sources/dojo/when.js

@@ -0,0 +1,55 @@
+define([
+	"./Deferred",
+	"./promise/Promise"
+], function(Deferred, Promise){
+	"use strict";
+
+	// module:
+	//		dojo/when
+
+	return function when(valueOrPromise, callback, errback, progback){
+		// summary:
+		//		Transparently applies callbacks to values and/or promises.
+		// description:
+		//		Accepts promises but also transparently handles non-promises. If no
+		//		callbacks are provided returns a promise, regardless of the initial
+		//		value. Foreign promises are converted.
+		//
+		//		If callbacks are provided and the initial value is not a promise,
+		//		the callback is executed immediately with no error handling. Returns
+		//		a promise if the initial value is a promise, or the result of the
+		//		callback otherwise.
+		// valueOrPromise:
+		//		Either a regular value or an object with a `then()` method that
+		//		follows the Promises/A specification.
+		// callback: Function?
+		//		Callback to be invoked when the promise is resolved, or a non-promise
+		//		is received.
+		// errback: Function?
+		//		Callback to be invoked when the promise is rejected.
+		// progback: Function?
+		//		Callback to be invoked when the promise emits a progress update.
+		// returns: dojo/promise/Promise
+		//		Promise, or if a callback is provided, the result of the callback.
+
+		var receivedPromise = valueOrPromise && typeof valueOrPromise.then === "function";
+		var nativePromise = receivedPromise && valueOrPromise instanceof Promise;
+
+		if(!receivedPromise){
+			if(arguments.length > 1){
+				return callback ? callback(valueOrPromise) : valueOrPromise;
+			}else{
+				return new Deferred().resolve(valueOrPromise);
+			}
+		}else if(!nativePromise){
+			var deferred = new Deferred(valueOrPromise.cancel);
+			valueOrPromise.then(deferred.resolve, deferred.reject, deferred.progress);
+			valueOrPromise = deferred.promise;
+		}
+
+		if(callback || errback || progback){
+			return valueOrPromise.then(callback, errback, progback);
+		}
+		return valueOrPromise;
+	};
+});

debian/missing-sources/patternfly.js

@@ -0,0 +1,212 @@
+// PatternFly Namespace
+var PatternFly = PatternFly || {};
+
+// Util: PatternFly Sidebar 
+// Set height of sidebar-pf to height of document minus height of navbar-pf if not mobile
+(function($) {
+  sidebar = function() {
+    var documentHeight = 0;
+    var navbarpfHeight = 0;
+    var colHeight = 0;
+    if ( $('.navbar-pf .navbar-toggle').is(':hidden') ) {
+      documentHeight = $(document).height();
+      navbarpfHeight = $('.navbar-pf').outerHeight();
+      colHeight = documentHeight - navbarpfHeight;
+    }
+    $('.sidebar-pf').parent('.row').children('[class*="col-"]').css({ "min-height":colHeight});
+  }
+  $(document).ready(function() {
+    // Call sidebar() on ready if .sidebar-pf exists and .datatable does not exist
+    if ($('.sidebar-pf').length > 0 && $('.datatable').length == 0) {
+      sidebar();
+    }
+  });
+  $(window).resize(function() {
+    // Call sidebar() on resize if .sidebar-pf exists
+    if ($('.sidebar-pf').length > 0) {
+      sidebar();
+    }
+  });
+})(jQuery);
+
+// Util: PatternFly Popovers
+// Add data-close="true" to insert close X icon
+(function($) {
+  PatternFly.popovers = function( selector ) {
+    var allpopovers = $(selector);
+    
+    // Initialize
+    allpopovers.popover();
+    
+    // Add close icons
+    allpopovers.filter('[data-close=true]').each(function(index, element) {
+      var $this = $(element),
+        title = $this.attr('data-original-title') + '<button type="button" class="close" aria-hidden="true"><span class="pficon pficon-close"></span></button>';
+
+      $this.attr('data-original-title', title);
+    });
+    
+    // Bind Close Icon to Toggle Display
+    allpopovers.on('click', function(e) {
+      var $this = $(this);
+        $title = $this.next('.popover').find('.popover-title');
+      
+      // Only if data-close is true add class "x" to title for right padding
+      $title.find('.close').parent('.popover-title').addClass('closable');
+      
+      // Bind x icon to close popover
+      $title.find('.close').on('click', function() {
+        $this.popover('toggle');
+      });
+      
+      // Prevent href="#" page scroll to top
+      e.preventDefault();
+    });
+  };
+})(jQuery);
+
+
+// Util: DataTables Settings
+(function($) {
+  if ($.fn.dataTableExt) {
+    /* Set the defaults for DataTables initialisation */
+    $.extend( true, $.fn.dataTable.defaults, {
+      "bDestroy": true,
+      "bAutoWidth": false,
+      "iDisplayLength": 20,
+      "sDom": 
+        "<'dataTables_header' f i r >" + 
+        "<'table-responsive'  t >" + 
+        "<'dataTables_footer' p >",
+      "oLanguage": {
+        "sInfo": "Showing <b>_START_</b> to <b>_END_</b> of <b>_TOTAL_</b> Items",
+        "sInfoFiltered" : "(of <b>_MAX_</b>)",
+        "sInfoEmpty" : "Showing <b>0</b> Results",
+        "sZeroRecords": 
+          "<p>Suggestions</p>" + 
+          "<ul>" + 
+            "<li>Check the syntax of the search term.</li>" +
+            "<li>Check that the correct menu option is chosen (token ID vs. user ID).</li>" +
+            "<li>Use wildcards (* to match zero or more characters or ? to match a single character).</li>" +
+            "<li>Clear the search field, then click Search to return to the 20 most recent records.</li>" +
+          "</ul>",
+        "sSearch": ""
+      },
+      "sPaginationType": "bootstrap_input"
+    });
+
+    /* Default class modification */
+    $.extend( $.fn.dataTableExt.oStdClasses, {
+      "sWrapper": "dataTables_wrapper"
+    });
+
+    /* API method to get paging information */
+    $.fn.dataTableExt.oApi.fnPagingInfo = function ( oSettings ) {
+      return {
+        "iStart":         oSettings._iDisplayStart,
+        "iEnd":           oSettings.fnDisplayEnd(),
+        "iLength":        oSettings._iDisplayLength,
+        "iTotal":         oSettings.fnRecordsTotal(),
+        "iFilteredTotal": oSettings.fnRecordsDisplay(),
+        "iPage":          oSettings._iDisplayLength === -1 ?
+          0 : Math.ceil( oSettings._iDisplayStart / oSettings._iDisplayLength ),
+        "iTotalPages":    oSettings._iDisplayLength === -1 ?
+          0 : Math.ceil( oSettings.fnRecordsDisplay() / oSettings._iDisplayLength )
+      };
+    };
+
+    /* Combination of Bootstrap + Input Text style pagination control */
+    $.extend( $.fn.dataTableExt.oPagination, {
+      "bootstrap_input": {
+        "fnInit": function( oSettings, nPaging, fnDraw ) {
+          var oLang = oSettings.oLanguage.oPaginate;
+          var fnClickHandler = function ( e ) {
+            e.preventDefault();
+            if ( oSettings.oApi._fnPageChange(oSettings, e.data.action) ) {
+              fnDraw( oSettings );
+            }
+          };
+
+          $(nPaging).append(
+            '<ul class="pagination">'+
+              '<li class="first disabled"><span class="i fa fa-angle-double-left"></span></li>' +
+              '<li class="prev disabled"><span class="i fa fa-angle-left"></span></li>' +
+            '</ul>' + 
+            '<div class="pagination-input">' + 
+              '<input type="text" class="paginate_input">' + 
+              '<span class="paginate_of">of <b>3</b></span>' + 
+            '</div>' + 
+            '<ul class="pagination">'+
+              '<li class="next disabled"><span class="i fa fa-angle-right"></span></li>' +
+              '<li class="last disabled"><span class="i fa fa-angle-double-right"></span></li>' +
+            '</ul>'
+          );
+          
+          var els = $('li', nPaging);
+          $(els[0]).bind( 'click.DT', { action: "first" }, fnClickHandler );
+          $(els[1]).bind( 'click.DT', { action: "previous" }, fnClickHandler );
+          $(els[2]).bind( 'click.DT', { action: "next" }, fnClickHandler );
+          $(els[3]).bind( 'click.DT', { action: "last" }, fnClickHandler );
+          
+          var nInput = $('input', nPaging);
+          $(nInput).keyup( function (e) {
+              if ( e.which == 38 || e.which == 39 ) {
+                this.value++;
+              }
+              else if ( (e.which == 37 || e.which == 40) && this.value > 1 ) {
+                this.value--;
+              }
+                
+              if ( this.value == "" || this.value.match(/[^0-9]/) ) {
+                /* Nothing entered or non-numeric character */
+                return;
+              }
+                
+              var iNewStart = oSettings._iDisplayLength * (this.value - 1);
+              if ( iNewStart > oSettings.fnRecordsDisplay() ) {
+                /* Display overrun */
+                oSettings._iDisplayStart = (Math.ceil((oSettings.fnRecordsDisplay()-1) /
+                  oSettings._iDisplayLength)-1) * oSettings._iDisplayLength;
+                fnDraw( oSettings );
+                return;
+              }
+                
+              oSettings._iDisplayStart = iNewStart;
+              fnDraw( oSettings );
+          });
+        },
+
+        "fnUpdate": function ( oSettings, fnDraw ) {
+          var oPaging = oSettings.oInstance.fnPagingInfo(),
+            an = oSettings.aanFeatures.p,
+            i,
+            ien,
+            iPages = Math.ceil((oSettings.fnRecordsDisplay()) / oSettings._iDisplayLength),
+            iCurrentPage = Math.ceil(oSettings._iDisplayStart / oSettings._iDisplayLength) + 1;
+
+          for ( i=0, ien=an.length ; i<ien ; i++ ) {
+            $('.paginate_input').val(iCurrentPage);
+            $('.paginate_of b').html(iPages);
+            
+            // Add / remove disabled classes from the static elements
+            if ( oPaging.iPage === 0 ) {
+              $('li.first', an[i]).addClass('disabled');
+              $('li.prev', an[i]).addClass('disabled');
+            } else {
+              $('li.first', an[i]).removeClass('disabled');
+              $('li.prev', an[i]).removeClass('disabled');
+            }
+
+            if ( oPaging.iPage === oPaging.iTotalPages-1 || oPaging.iTotalPages === 0 ) {
+              $('li.next', an[i]).addClass('disabled');
+              $('li.last', an[i]).addClass('disabled');
+            } else {
+              $('li.next', an[i]).removeClass('disabled');
+              $('li.last', an[i]).removeClass('disabled');
+            }
+          }
+        }
+      }
+    });
+  }
+})(jQuery);

debian/missing-sources/qrcode.js

@@ -0,0 +1,614 @@
+/**
+ * @fileoverview
+ * - Using the 'QRCode for Javascript library'
+ * - Fixed dataset of 'QRCode for Javascript library' for support full-spec.
+ * - this library has no dependencies.
+ * 
+ * @author davidshimjs
+ * @see <a href="http://www.d-project.com/" target="_blank">http://www.d-project.com/</a>
+ * @see <a href="http://jeromeetienne.github.com/jquery-qrcode/" target="_blank">http://jeromeetienne.github.com/jquery-qrcode/</a>
+ */
+var QRCode;
+
+(function () {
+	//---------------------------------------------------------------------
+	// QRCode for JavaScript
+	//
+	// Copyright (c) 2009 Kazuhiko Arase
+	//
+	// URL: http://www.d-project.com/
+	//
+	// Licensed under the MIT license:
+	//   http://www.opensource.org/licenses/mit-license.php
+	//
+	// The word "QR Code" is registered trademark of 
+	// DENSO WAVE INCORPORATED
+	//   http://www.denso-wave.com/qrcode/faqpatent-e.html
+	//
+	//---------------------------------------------------------------------
+	function QR8bitByte(data) {
+		this.mode = QRMode.MODE_8BIT_BYTE;
+		this.data = data;
+		this.parsedData = [];
+
+		// Added to support UTF-8 Characters
+		for (var i = 0, l = this.data.length; i < l; i++) {
+			var byteArray = [];
+			var code = this.data.charCodeAt(i);
+
+			if (code > 0x10000) {
+				byteArray[0] = 0xF0 | ((code & 0x1C0000) >>> 18);
+				byteArray[1] = 0x80 | ((code & 0x3F000) >>> 12);
+				byteArray[2] = 0x80 | ((code & 0xFC0) >>> 6);
+				byteArray[3] = 0x80 | (code & 0x3F);
+			} else if (code > 0x800) {
+				byteArray[0] = 0xE0 | ((code & 0xF000) >>> 12);
+				byteArray[1] = 0x80 | ((code & 0xFC0) >>> 6);
+				byteArray[2] = 0x80 | (code & 0x3F);
+			} else if (code > 0x80) {
+				byteArray[0] = 0xC0 | ((code & 0x7C0) >>> 6);
+				byteArray[1] = 0x80 | (code & 0x3F);
+			} else {
+				byteArray[0] = code;
+			}
+
+			this.parsedData.push(byteArray);
+		}
+
+		this.parsedData = Array.prototype.concat.apply([], this.parsedData);
+
+		if (this.parsedData.length != this.data.length) {
+			this.parsedData.unshift(191);
+			this.parsedData.unshift(187);
+			this.parsedData.unshift(239);
+		}
+	}
+
+	QR8bitByte.prototype = {
+		getLength: function (buffer) {
+			return this.parsedData.length;
+		},
+		write: function (buffer) {
+			for (var i = 0, l = this.parsedData.length; i < l; i++) {
+				buffer.put(this.parsedData[i], 8);
+			}
+		}
+	};
+
+	function QRCodeModel(typeNumber, errorCorrectLevel) {
+		this.typeNumber = typeNumber;
+		this.errorCorrectLevel = errorCorrectLevel;
+		this.modules = null;
+		this.moduleCount = 0;
+		this.dataCache = null;
+		this.dataList = [];
+	}
+
+	QRCodeModel.prototype={addData:function(data){var newData=new QR8bitByte(data);this.dataList.push(newData);this.dataCache=null;},isDark:function(row,col){if(row<0||this.moduleCount<=row||col<0||this.moduleCount<=col){throw new Error(row+","+col);}
+	return this.modules[row][col];},getModuleCount:function(){return this.moduleCount;},make:function(){this.makeImpl(false,this.getBestMaskPattern());},makeImpl:function(test,maskPattern){this.moduleCount=this.typeNumber*4+17;this.modules=new Array(this.moduleCount);for(var row=0;row<this.moduleCount;row++){this.modules[row]=new Array(this.moduleCount);for(var col=0;col<this.moduleCount;col++){this.modules[row][col]=null;}}
+	this.setupPositionProbePattern(0,0);this.setupPositionProbePattern(this.moduleCount-7,0);this.setupPositionProbePattern(0,this.moduleCount-7);this.setupPositionAdjustPattern();this.setupTimingPattern();this.setupTypeInfo(test,maskPattern);if(this.typeNumber>=7){this.setupTypeNumber(test);}
+	if(this.dataCache==null){this.dataCache=QRCodeModel.createData(this.typeNumber,this.errorCorrectLevel,this.dataList);}
+	this.mapData(this.dataCache,maskPattern);},setupPositionProbePattern:function(row,col){for(var r=-1;r<=7;r++){if(row+r<=-1||this.moduleCount<=row+r)continue;for(var c=-1;c<=7;c++){if(col+c<=-1||this.moduleCount<=col+c)continue;if((0<=r&&r<=6&&(c==0||c==6))||(0<=c&&c<=6&&(r==0||r==6))||(2<=r&&r<=4&&2<=c&&c<=4)){this.modules[row+r][col+c]=true;}else{this.modules[row+r][col+c]=false;}}}},getBestMaskPattern:function(){var minLostPoint=0;var pattern=0;for(var i=0;i<8;i++){this.makeImpl(true,i);var lostPoint=QRUtil.getLostPoint(this);if(i==0||minLostPoint>lostPoint){minLostPoint=lostPoint;pattern=i;}}
+	return pattern;},createMovieClip:function(target_mc,instance_name,depth){var qr_mc=target_mc.createEmptyMovieClip(instance_name,depth);var cs=1;this.make();for(var row=0;row<this.modules.length;row++){var y=row*cs;for(var col=0;col<this.modules[row].length;col++){var x=col*cs;var dark=this.modules[row][col];if(dark){qr_mc.beginFill(0,100);qr_mc.moveTo(x,y);qr_mc.lineTo(x+cs,y);qr_mc.lineTo(x+cs,y+cs);qr_mc.lineTo(x,y+cs);qr_mc.endFill();}}}
+	return qr_mc;},setupTimingPattern:function(){for(var r=8;r<this.moduleCount-8;r++){if(this.modules[r][6]!=null){continue;}
+	this.modules[r][6]=(r%2==0);}
+	for(var c=8;c<this.moduleCount-8;c++){if(this.modules[6][c]!=null){continue;}
+	this.modules[6][c]=(c%2==0);}},setupPositionAdjustPattern:function(){var pos=QRUtil.getPatternPosition(this.typeNumber);for(var i=0;i<pos.length;i++){for(var j=0;j<pos.length;j++){var row=pos[i];var col=pos[j];if(this.modules[row][col]!=null){continue;}
+	for(var r=-2;r<=2;r++){for(var c=-2;c<=2;c++){if(r==-2||r==2||c==-2||c==2||(r==0&&c==0)){this.modules[row+r][col+c]=true;}else{this.modules[row+r][col+c]=false;}}}}}},setupTypeNumber:function(test){var bits=QRUtil.getBCHTypeNumber(this.typeNumber);for(var i=0;i<18;i++){var mod=(!test&&((bits>>i)&1)==1);this.modules[Math.floor(i/3)][i%3+this.moduleCount-8-3]=mod;}
+	for(var i=0;i<18;i++){var mod=(!test&&((bits>>i)&1)==1);this.modules[i%3+this.moduleCount-8-3][Math.floor(i/3)]=mod;}},setupTypeInfo:function(test,maskPattern){var data=(this.errorCorrectLevel<<3)|maskPattern;var bits=QRUtil.getBCHTypeInfo(data);for(var i=0;i<15;i++){var mod=(!test&&((bits>>i)&1)==1);if(i<6){this.modules[i][8]=mod;}else if(i<8){this.modules[i+1][8]=mod;}else{this.modules[this.moduleCount-15+i][8]=mod;}}
+	for(var i=0;i<15;i++){var mod=(!test&&((bits>>i)&1)==1);if(i<8){this.modules[8][this.moduleCount-i-1]=mod;}else if(i<9){this.modules[8][15-i-1+1]=mod;}else{this.modules[8][15-i-1]=mod;}}
+	this.modules[this.moduleCount-8][8]=(!test);},mapData:function(data,maskPattern){var inc=-1;var row=this.moduleCount-1;var bitIndex=7;var byteIndex=0;for(var col=this.moduleCount-1;col>0;col-=2){if(col==6)col--;while(true){for(var c=0;c<2;c++){if(this.modules[row][col-c]==null){var dark=false;if(byteIndex<data.length){dark=(((data[byteIndex]>>>bitIndex)&1)==1);}
+	var mask=QRUtil.getMask(maskPattern,row,col-c);if(mask){dark=!dark;}
+	this.modules[row][col-c]=dark;bitIndex--;if(bitIndex==-1){byteIndex++;bitIndex=7;}}}
+	row+=inc;if(row<0||this.moduleCount<=row){row-=inc;inc=-inc;break;}}}}};QRCodeModel.PAD0=0xEC;QRCodeModel.PAD1=0x11;QRCodeModel.createData=function(typeNumber,errorCorrectLevel,dataList){var rsBlocks=QRRSBlock.getRSBlocks(typeNumber,errorCorrectLevel);var buffer=new QRBitBuffer();for(var i=0;i<dataList.length;i++){var data=dataList[i];buffer.put(data.mode,4);buffer.put(data.getLength(),QRUtil.getLengthInBits(data.mode,typeNumber));data.write(buffer);}
+	var totalDataCount=0;for(var i=0;i<rsBlocks.length;i++){totalDataCount+=rsBlocks[i].dataCount;}
+	if(buffer.getLengthInBits()>totalDataCount*8){throw new Error("code length overflow. ("
+	+buffer.getLengthInBits()
+	+">"
+	+totalDataCount*8
+	+")");}
+	if(buffer.getLengthInBits()+4<=totalDataCount*8){buffer.put(0,4);}
+	while(buffer.getLengthInBits()%8!=0){buffer.putBit(false);}
+	while(true){if(buffer.getLengthInBits()>=totalDataCount*8){break;}
+	buffer.put(QRCodeModel.PAD0,8);if(buffer.getLengthInBits()>=totalDataCount*8){break;}
+	buffer.put(QRCodeModel.PAD1,8);}
+	return QRCodeModel.createBytes(buffer,rsBlocks);};QRCodeModel.createBytes=function(buffer,rsBlocks){var offset=0;var maxDcCount=0;var maxEcCount=0;var dcdata=new Array(rsBlocks.length);var ecdata=new Array(rsBlocks.length);for(var r=0;r<rsBlocks.length;r++){var dcCount=rsBlocks[r].dataCount;var ecCount=rsBlocks[r].totalCount-dcCount;maxDcCount=Math.max(maxDcCount,dcCount);maxEcCount=Math.max(maxEcCount,ecCount);dcdata[r]=new Array(dcCount);for(var i=0;i<dcdata[r].length;i++){dcdata[r][i]=0xff&buffer.buffer[i+offset];}
+	offset+=dcCount;var rsPoly=QRUtil.getErrorCorrectPolynomial(ecCount);var rawPoly=new QRPolynomial(dcdata[r],rsPoly.getLength()-1);var modPoly=rawPoly.mod(rsPoly);ecdata[r]=new Array(rsPoly.getLength()-1);for(var i=0;i<ecdata[r].length;i++){var modIndex=i+modPoly.getLength()-ecdata[r].length;ecdata[r][i]=(modIndex>=0)?modPoly.get(modIndex):0;}}
+	var totalCodeCount=0;for(var i=0;i<rsBlocks.length;i++){totalCodeCount+=rsBlocks[i].totalCount;}
+	var data=new Array(totalCodeCount);var index=0;for(var i=0;i<maxDcCount;i++){for(var r=0;r<rsBlocks.length;r++){if(i<dcdata[r].length){data[index++]=dcdata[r][i];}}}
+	for(var i=0;i<maxEcCount;i++){for(var r=0;r<rsBlocks.length;r++){if(i<ecdata[r].length){data[index++]=ecdata[r][i];}}}
+	return data;};var QRMode={MODE_NUMBER:1<<0,MODE_ALPHA_NUM:1<<1,MODE_8BIT_BYTE:1<<2,MODE_KANJI:1<<3};var QRErrorCorrectLevel={L:1,M:0,Q:3,H:2};var QRMaskPattern={PATTERN000:0,PATTERN001:1,PATTERN010:2,PATTERN011:3,PATTERN100:4,PATTERN101:5,PATTERN110:6,PATTERN111:7};var QRUtil={PATTERN_POSITION_TABLE:[[],[6,18],[6,22],[6,26],[6,30],[6,34],[6,22,38],[6,24,42],[6,26,46],[6,28,50],[6,30,54],[6,32,58],[6,34,62],[6,26,46,66],[6,26,48,70],[6,26,50,74],[6,30,54,78],[6,30,56,82],[6,30,58,86],[6,34,62,90],[6,28,50,72,94],[6,26,50,74,98],[6,30,54,78,102],[6,28,54,80,106],[6,32,58,84,110],[6,30,58,86,114],[6,34,62,90,118],[6,26,50,74,98,122],[6,30,54,78,102,126],[6,26,52,78,104,130],[6,30,56,82,108,134],[6,34,60,86,112,138],[6,30,58,86,114,142],[6,34,62,90,118,146],[6,30,54,78,102,126,150],[6,24,50,76,102,128,154],[6,28,54,80,106,132,158],[6,32,58,84,110,136,162],[6,26,54,82,110,138,166],[6,30,58,86,114,142,170]],G15:(1<<10)|(1<<8)|(1<<5)|(1<<4)|(1<<2)|(1<<1)|(1<<0),G18:(1<<12)|(1<<11)|(1<<10)|(1<<9)|(1<<8)|(1<<5)|(1<<2)|(1<<0),G15_MASK:(1<<14)|(1<<12)|(1<<10)|(1<<4)|(1<<1),getBCHTypeInfo:function(data){var d=data<<10;while(QRUtil.getBCHDigit(d)-QRUtil.getBCHDigit(QRUtil.G15)>=0){d^=(QRUtil.G15<<(QRUtil.getBCHDigit(d)-QRUtil.getBCHDigit(QRUtil.G15)));}
+	return((data<<10)|d)^QRUtil.G15_MASK;},getBCHTypeNumber:function(data){var d=data<<12;while(QRUtil.getBCHDigit(d)-QRUtil.getBCHDigit(QRUtil.G18)>=0){d^=(QRUtil.G18<<(QRUtil.getBCHDigit(d)-QRUtil.getBCHDigit(QRUtil.G18)));}
+	return(data<<12)|d;},getBCHDigit:function(data){var digit=0;while(data!=0){digit++;data>>>=1;}
+	return digit;},getPatternPosition:function(typeNumber){return QRUtil.PATTERN_POSITION_TABLE[typeNumber-1];},getMask:function(maskPattern,i,j){switch(maskPattern){case QRMaskPattern.PATTERN000:return(i+j)%2==0;case QRMaskPattern.PATTERN001:return i%2==0;case QRMaskPattern.PATTERN010:return j%3==0;case QRMaskPattern.PATTERN011:return(i+j)%3==0;case QRMaskPattern.PATTERN100:return(Math.floor(i/2)+Math.floor(j/3))%2==0;case QRMaskPattern.PATTERN101:return(i*j)%2+(i*j)%3==0;case QRMaskPattern.PATTERN110:return((i*j)%2+(i*j)%3)%2==0;case QRMaskPattern.PATTERN111:return((i*j)%3+(i+j)%2)%2==0;default:throw new Error("bad maskPattern:"+maskPattern);}},getErrorCorrectPolynomial:function(errorCorrectLength){var a=new QRPolynomial([1],0);for(var i=0;i<errorCorrectLength;i++){a=a.multiply(new QRPolynomial([1,QRMath.gexp(i)],0));}
+	return a;},getLengthInBits:function(mode,type){if(1<=type&&type<10){switch(mode){case QRMode.MODE_NUMBER:return 10;case QRMode.MODE_ALPHA_NUM:return 9;case QRMode.MODE_8BIT_BYTE:return 8;case QRMode.MODE_KANJI:return 8;default:throw new Error("mode:"+mode);}}else if(type<27){switch(mode){case QRMode.MODE_NUMBER:return 12;case QRMode.MODE_ALPHA_NUM:return 11;case QRMode.MODE_8BIT_BYTE:return 16;case QRMode.MODE_KANJI:return 10;default:throw new Error("mode:"+mode);}}else if(type<41){switch(mode){case QRMode.MODE_NUMBER:return 14;case QRMode.MODE_ALPHA_NUM:return 13;case QRMode.MODE_8BIT_BYTE:return 16;case QRMode.MODE_KANJI:return 12;default:throw new Error("mode:"+mode);}}else{throw new Error("type:"+type);}},getLostPoint:function(qrCode){var moduleCount=qrCode.getModuleCount();var lostPoint=0;for(var row=0;row<moduleCount;row++){for(var col=0;col<moduleCount;col++){var sameCount=0;var dark=qrCode.isDark(row,col);for(var r=-1;r<=1;r++){if(row+r<0||moduleCount<=row+r){continue;}
+	for(var c=-1;c<=1;c++){if(col+c<0||moduleCount<=col+c){continue;}
+	if(r==0&&c==0){continue;}
+	if(dark==qrCode.isDark(row+r,col+c)){sameCount++;}}}
+	if(sameCount>5){lostPoint+=(3+sameCount-5);}}}
+	for(var row=0;row<moduleCount-1;row++){for(var col=0;col<moduleCount-1;col++){var count=0;if(qrCode.isDark(row,col))count++;if(qrCode.isDark(row+1,col))count++;if(qrCode.isDark(row,col+1))count++;if(qrCode.isDark(row+1,col+1))count++;if(count==0||count==4){lostPoint+=3;}}}
+	for(var row=0;row<moduleCount;row++){for(var col=0;col<moduleCount-6;col++){if(qrCode.isDark(row,col)&&!qrCode.isDark(row,col+1)&&qrCode.isDark(row,col+2)&&qrCode.isDark(row,col+3)&&qrCode.isDark(row,col+4)&&!qrCode.isDark(row,col+5)&&qrCode.isDark(row,col+6)){lostPoint+=40;}}}
+	for(var col=0;col<moduleCount;col++){for(var row=0;row<moduleCount-6;row++){if(qrCode.isDark(row,col)&&!qrCode.isDark(row+1,col)&&qrCode.isDark(row+2,col)&&qrCode.isDark(row+3,col)&&qrCode.isDark(row+4,col)&&!qrCode.isDark(row+5,col)&&qrCode.isDark(row+6,col)){lostPoint+=40;}}}
+	var darkCount=0;for(var col=0;col<moduleCount;col++){for(var row=0;row<moduleCount;row++){if(qrCode.isDark(row,col)){darkCount++;}}}
+	var ratio=Math.abs(100*darkCount/moduleCount/moduleCount-50)/5;lostPoint+=ratio*10;return lostPoint;}};var QRMath={glog:function(n){if(n<1){throw new Error("glog("+n+")");}
+	return QRMath.LOG_TABLE[n];},gexp:function(n){while(n<0){n+=255;}
+	while(n>=256){n-=255;}
+	return QRMath.EXP_TABLE[n];},EXP_TABLE:new Array(256),LOG_TABLE:new Array(256)};for(var i=0;i<8;i++){QRMath.EXP_TABLE[i]=1<<i;}
+	for(var i=8;i<256;i++){QRMath.EXP_TABLE[i]=QRMath.EXP_TABLE[i-4]^QRMath.EXP_TABLE[i-5]^QRMath.EXP_TABLE[i-6]^QRMath.EXP_TABLE[i-8];}
+	for(var i=0;i<255;i++){QRMath.LOG_TABLE[QRMath.EXP_TABLE[i]]=i;}
+	function QRPolynomial(num,shift){if(num.length==undefined){throw new Error(num.length+"/"+shift);}
+	var offset=0;while(offset<num.length&&num[offset]==0){offset++;}
+	this.num=new Array(num.length-offset+shift);for(var i=0;i<num.length-offset;i++){this.num[i]=num[i+offset];}}
+	QRPolynomial.prototype={get:function(index){return this.num[index];},getLength:function(){return this.num.length;},multiply:function(e){var num=new Array(this.getLength()+e.getLength()-1);for(var i=0;i<this.getLength();i++){for(var j=0;j<e.getLength();j++){num[i+j]^=QRMath.gexp(QRMath.glog(this.get(i))+QRMath.glog(e.get(j)));}}
+	return new QRPolynomial(num,0);},mod:function(e){if(this.getLength()-e.getLength()<0){return this;}
+	var ratio=QRMath.glog(this.get(0))-QRMath.glog(e.get(0));var num=new Array(this.getLength());for(var i=0;i<this.getLength();i++){num[i]=this.get(i);}
+	for(var i=0;i<e.getLength();i++){num[i]^=QRMath.gexp(QRMath.glog(e.get(i))+ratio);}
+	return new QRPolynomial(num,0).mod(e);}};function QRRSBlock(totalCount,dataCount){this.totalCount=totalCount;this.dataCount=dataCount;}
+	QRRSBlock.RS_BLOCK_TABLE=[[1,26,19],[1,26,16],[1,26,13],[1,26,9],[1,44,34],[1,44,28],[1,44,22],[1,44,16],[1,70,55],[1,70,44],[2,35,17],[2,35,13],[1,100,80],[2,50,32],[2,50,24],[4,25,9],[1,134,108],[2,67,43],[2,33,15,2,34,16],[2,33,11,2,34,12],[2,86,68],[4,43,27],[4,43,19],[4,43,15],[2,98,78],[4,49,31],[2,32,14,4,33,15],[4,39,13,1,40,14],[2,121,97],[2,60,38,2,61,39],[4,40,18,2,41,19],[4,40,14,2,41,15],[2,146,116],[3,58,36,2,59,37],[4,36,16,4,37,17],[4,36,12,4,37,13],[2,86,68,2,87,69],[4,69,43,1,70,44],[6,43,19,2,44,20],[6,43,15,2,44,16],[4,101,81],[1,80,50,4,81,51],[4,50,22,4,51,23],[3,36,12,8,37,13],[2,116,92,2,117,93],[6,58,36,2,59,37],[4,46,20,6,47,21],[7,42,14,4,43,15],[4,133,107],[8,59,37,1,60,38],[8,44,20,4,45,21],[12,33,11,4,34,12],[3,145,115,1,146,116],[4,64,40,5,65,41],[11,36,16,5,37,17],[11,36,12,5,37,13],[5,109,87,1,110,88],[5,65,41,5,66,42],[5,54,24,7,55,25],[11,36,12],[5,122,98,1,123,99],[7,73,45,3,74,46],[15,43,19,2,44,20],[3,45,15,13,46,16],[1,135,107,5,136,108],[10,74,46,1,75,47],[1,50,22,15,51,23],[2,42,14,17,43,15],[5,150,120,1,151,121],[9,69,43,4,70,44],[17,50,22,1,51,23],[2,42,14,19,43,15],[3,141,113,4,142,114],[3,70,44,11,71,45],[17,47,21,4,48,22],[9,39,13,16,40,14],[3,135,107,5,136,108],[3,67,41,13,68,42],[15,54,24,5,55,25],[15,43,15,10,44,16],[4,144,116,4,145,117],[17,68,42],[17,50,22,6,51,23],[19,46,16,6,47,17],[2,139,111,7,140,112],[17,74,46],[7,54,24,16,55,25],[34,37,13],[4,151,121,5,152,122],[4,75,47,14,76,48],[11,54,24,14,55,25],[16,45,15,14,46,16],[6,147,117,4,148,118],[6,73,45,14,74,46],[11,54,24,16,55,25],[30,46,16,2,47,17],[8,132,106,4,133,107],[8,75,47,13,76,48],[7,54,24,22,55,25],[22,45,15,13,46,16],[10,142,114,2,143,115],[19,74,46,4,75,47],[28,50,22,6,51,23],[33,46,16,4,47,17],[8,152,122,4,153,123],[22,73,45,3,74,46],[8,53,23,26,54,24],[12,45,15,28,46,16],[3,147,117,10,148,118],[3,73,45,23,74,46],[4,54,24,31,55,25],[11,45,15,31,46,16],[7,146,116,7,147,117],[21,73,45,7,74,46],[1,53,23,37,54,24],[19,45,15,26,46,16],[5,145,115,10,146,116],[19,75,47,10,76,48],[15,54,24,25,55,25],[23,45,15,25,46,16],[13,145,115,3,146,116],[2,74,46,29,75,47],[42,54,24,1,55,25],[23,45,15,28,46,16],[17,145,115],[10,74,46,23,75,47],[10,54,24,35,55,25],[19,45,15,35,46,16],[17,145,115,1,146,116],[14,74,46,21,75,47],[29,54,24,19,55,25],[11,45,15,46,46,16],[13,145,115,6,146,116],[14,74,46,23,75,47],[44,54,24,7,55,25],[59,46,16,1,47,17],[12,151,121,7,152,122],[12,75,47,26,76,48],[39,54,24,14,55,25],[22,45,15,41,46,16],[6,151,121,14,152,122],[6,75,47,34,76,48],[46,54,24,10,55,25],[2,45,15,64,46,16],[17,152,122,4,153,123],[29,74,46,14,75,47],[49,54,24,10,55,25],[24,45,15,46,46,16],[4,152,122,18,153,123],[13,74,46,32,75,47],[48,54,24,14,55,25],[42,45,15,32,46,16],[20,147,117,4,148,118],[40,75,47,7,76,48],[43,54,24,22,55,25],[10,45,15,67,46,16],[19,148,118,6,149,119],[18,75,47,31,76,48],[34,54,24,34,55,25],[20,45,15,61,46,16]];QRRSBlock.getRSBlocks=function(typeNumber,errorCorrectLevel){var rsBlock=QRRSBlock.getRsBlockTable(typeNumber,errorCorrectLevel);if(rsBlock==undefined){throw new Error("bad rs block @ typeNumber:"+typeNumber+"/errorCorrectLevel:"+errorCorrectLevel);}
+	var length=rsBlock.length/3;var list=[];for(var i=0;i<length;i++){var count=rsBlock[i*3+0];var totalCount=rsBlock[i*3+1];var dataCount=rsBlock[i*3+2];for(var j=0;j<count;j++){list.push(new QRRSBlock(totalCount,dataCount));}}
+	return list;};QRRSBlock.getRsBlockTable=function(typeNumber,errorCorrectLevel){switch(errorCorrectLevel){case QRErrorCorrectLevel.L:return QRRSBlock.RS_BLOCK_TABLE[(typeNumber-1)*4+0];case QRErrorCorrectLevel.M:return QRRSBlock.RS_BLOCK_TABLE[(typeNumber-1)*4+1];case QRErrorCorrectLevel.Q:return QRRSBlock.RS_BLOCK_TABLE[(typeNumber-1)*4+2];case QRErrorCorrectLevel.H:return QRRSBlock.RS_BLOCK_TABLE[(typeNumber-1)*4+3];default:return undefined;}};function QRBitBuffer(){this.buffer=[];this.length=0;}
+	QRBitBuffer.prototype={get:function(index){var bufIndex=Math.floor(index/8);return((this.buffer[bufIndex]>>>(7-index%8))&1)==1;},put:function(num,length){for(var i=0;i<length;i++){this.putBit(((num>>>(length-i-1))&1)==1);}},getLengthInBits:function(){return this.length;},putBit:function(bit){var bufIndex=Math.floor(this.length/8);if(this.buffer.length<=bufIndex){this.buffer.push(0);}
+	if(bit){this.buffer[bufIndex]|=(0x80>>>(this.length%8));}
+	this.length++;}};var QRCodeLimitLength=[[17,14,11,7],[32,26,20,14],[53,42,32,24],[78,62,46,34],[106,84,60,44],[134,106,74,58],[154,122,86,64],[192,152,108,84],[230,180,130,98],[271,213,151,119],[321,251,177,137],[367,287,203,155],[425,331,241,177],[458,362,258,194],[520,412,292,220],[586,450,322,250],[644,504,364,280],[718,560,394,310],[792,624,442,338],[858,666,482,382],[929,711,509,403],[1003,779,565,439],[1091,857,611,461],[1171,911,661,511],[1273,997,715,535],[1367,1059,751,593],[1465,1125,805,625],[1528,1190,868,658],[1628,1264,908,698],[1732,1370,982,742],[1840,1452,1030,790],[1952,1538,1112,842],[2068,1628,1168,898],[2188,1722,1228,958],[2303,1809,1283,983],[2431,1911,1351,1051],[2563,1989,1423,1093],[2699,2099,1499,1139],[2809,2213,1579,1219],[2953,2331,1663,1273]];
+	
+	function _isSupportCanvas() {
+		return typeof CanvasRenderingContext2D != "undefined";
+	}
+	
+	// android 2.x doesn't support Data-URI spec
+	function _getAndroid() {
+		var android = false;
+		var sAgent = navigator.userAgent;
+		
+		if (/android/i.test(sAgent)) { // android
+			android = true;
+			var aMat = sAgent.toString().match(/android ([0-9]\.[0-9])/i);
+			
+			if (aMat && aMat[1]) {
+				android = parseFloat(aMat[1]);
+			}
+		}
+		
+		return android;
+	}
+	
+	var svgDrawer = (function() {
+
+		var Drawing = function (el, htOption) {
+			this._el = el;
+			this._htOption = htOption;
+		};
+
+		Drawing.prototype.draw = function (oQRCode) {
+			var _htOption = this._htOption;
+			var _el = this._el;
+			var nCount = oQRCode.getModuleCount();
+			var nWidth = Math.floor(_htOption.width / nCount);
+			var nHeight = Math.floor(_htOption.height / nCount);
+
+			this.clear();
+
+			function makeSVG(tag, attrs) {
+				var el = document.createElementNS('http://www.w3.org/2000/svg', tag);
+				for (var k in attrs)
+					if (attrs.hasOwnProperty(k)) el.setAttribute(k, attrs[k]);
+				return el;
+			}
+
+			var svg = makeSVG("svg" , {'viewBox': '0 0 ' + String(nCount) + " " + String(nCount), 'width': '100%', 'height': '100%', 'fill': _htOption.colorLight});
+			svg.setAttributeNS("http://www.w3.org/2000/xmlns/", "xmlns:xlink", "http://www.w3.org/1999/xlink");
+			_el.appendChild(svg);
+
+			svg.appendChild(makeSVG("rect", {"fill": _htOption.colorLight, "width": "100%", "height": "100%"}));
+			svg.appendChild(makeSVG("rect", {"fill": _htOption.colorDark, "width": "1", "height": "1", "id": "template"}));
+
+			for (var row = 0; row < nCount; row++) {
+				for (var col = 0; col < nCount; col++) {
+					if (oQRCode.isDark(row, col)) {
+						var child = makeSVG("use", {"x": String(col), "y": String(row)});
+						child.setAttributeNS("http://www.w3.org/1999/xlink", "href", "#template")
+						svg.appendChild(child);
+					}
+				}
+			}
+		};
+		Drawing.prototype.clear = function () {
+			while (this._el.hasChildNodes())
+				this._el.removeChild(this._el.lastChild);
+		};
+		return Drawing;
+	})();
+
+	var useSVG = document.documentElement.tagName.toLowerCase() === "svg";
+
+	// Drawing in DOM by using Table tag
+	var Drawing = useSVG ? svgDrawer : !_isSupportCanvas() ? (function () {
+		var Drawing = function (el, htOption) {
+			this._el = el;
+			this._htOption = htOption;
+		};
+			
+		/**
+		 * Draw the QRCode
+		 * 
+		 * @param {QRCode} oQRCode
+		 */
+		Drawing.prototype.draw = function (oQRCode) {
+            var _htOption = this._htOption;
+            var _el = this._el;
+			var nCount = oQRCode.getModuleCount();
+			var nWidth = Math.floor(_htOption.width / nCount);
+			var nHeight = Math.floor(_htOption.height / nCount);
+			var aHTML = ['<table style="border:0;border-collapse:collapse;">'];
+			
+			for (var row = 0; row < nCount; row++) {
+				aHTML.push('<tr>');
+				
+				for (var col = 0; col < nCount; col++) {
+					aHTML.push('<td style="border:0;border-collapse:collapse;padding:0;margin:0;width:' + nWidth + 'px;height:' + nHeight + 'px;background-color:' + (oQRCode.isDark(row, col) ? _htOption.colorDark : _htOption.colorLight) + ';"></td>');
+				}
+				
+				aHTML.push('</tr>');
+			}
+			
+			aHTML.push('</table>');
+			_el.innerHTML = aHTML.join('');
+			
+			// Fix the margin values as real size.
+			var elTable = _el.childNodes[0];
+			var nLeftMarginTable = (_htOption.width - elTable.offsetWidth) / 2;
+			var nTopMarginTable = (_htOption.height - elTable.offsetHeight) / 2;
+			
+			if (nLeftMarginTable > 0 && nTopMarginTable > 0) {
+				elTable.style.margin = nTopMarginTable + "px " + nLeftMarginTable + "px";	
+			}
+		};
+		
+		/**
+		 * Clear the QRCode
+		 */
+		Drawing.prototype.clear = function () {
+			this._el.innerHTML = '';
+		};
+		
+		return Drawing;
+	})() : (function () { // Drawing in Canvas
+		function _onMakeImage() {
+			this._elImage.src = this._elCanvas.toDataURL("image/png");
+			this._elImage.style.display = "block";
+			this._elCanvas.style.display = "none";			
+		}
+		
+		// Android 2.1 bug workaround
+		// http://code.google.com/p/android/issues/detail?id=5141
+		if (this._android && this._android <= 2.1) {
+	    	var factor = 1 / window.devicePixelRatio;
+	        var drawImage = CanvasRenderingContext2D.prototype.drawImage; 
+	    	CanvasRenderingContext2D.prototype.drawImage = function (image, sx, sy, sw, sh, dx, dy, dw, dh) {
+	    		if (("nodeName" in image) && /img/i.test(image.nodeName)) {
+		        	for (var i = arguments.length - 1; i >= 1; i--) {
+		            	arguments[i] = arguments[i] * factor;
+		        	}
+	    		} else if (typeof dw == "undefined") {
+	    			arguments[1] *= factor;
+	    			arguments[2] *= factor;
+	    			arguments[3] *= factor;
+	    			arguments[4] *= factor;
+	    		}
+	    		
+	        	drawImage.apply(this, arguments); 
+	    	};
+		}
+		
+		/**
+		 * Check whether the user's browser supports Data URI or not
+		 * 
+		 * @private
+		 * @param {Function} fSuccess Occurs if it supports Data URI
+		 * @param {Function} fFail Occurs if it doesn't support Data URI
+		 */
+		function _safeSetDataURI(fSuccess, fFail) {
+            var self = this;
+            self._fFail = fFail;
+            self._fSuccess = fSuccess;
+
+            // Check it just once
+            if (self._bSupportDataURI === null) {
+                var el = document.createElement("img");
+                var fOnError = function() {
+                    self._bSupportDataURI = false;
+
+                    if (self._fFail) {
+                        self._fFail.call(self);
+                    }
+                };
+                var fOnSuccess = function() {
+                    self._bSupportDataURI = true;
+
+                    if (self._fSuccess) {
+                        self._fSuccess.call(self);
+                    }
+                };
+
+                el.onabort = fOnError;
+                el.onerror = fOnError;
+                el.onload = fOnSuccess;
+                el.src = "data:image/gif;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHElEQVQI12P4//8/w38GIAXDIBKE0DHxgljNBAAO9TXL0Y4OHwAAAABJRU5ErkJggg=="; // the Image contains 1px data.
+                return;
+            } else if (self._bSupportDataURI === true && self._fSuccess) {
+                self._fSuccess.call(self);
+            } else if (self._bSupportDataURI === false && self._fFail) {
+                self._fFail.call(self);
+            }
+		};
+		
+		/**
+		 * Drawing QRCode by using canvas
+		 * 
+		 * @constructor
+		 * @param {HTMLElement} el
+		 * @param {Object} htOption QRCode Options 
+		 */
+		var Drawing = function (el, htOption) {
+    		this._bIsPainted = false;
+    		this._android = _getAndroid();
+		
+			this._htOption = htOption;
+			this._elCanvas = document.createElement("canvas");
+			this._elCanvas.width = htOption.width;
+			this._elCanvas.height = htOption.height;
+			el.appendChild(this._elCanvas);
+			this._el = el;
+			this._oContext = this._elCanvas.getContext("2d");
+			this._bIsPainted = false;
+			this._elImage = document.createElement("img");
+			this._elImage.alt = "Scan me!";
+			this._elImage.style.display = "none";
+			this._el.appendChild(this._elImage);
+			this._bSupportDataURI = null;
+		};
+			
+		/**
+		 * Draw the QRCode
+		 * 
+		 * @param {QRCode} oQRCode 
+		 */
+		Drawing.prototype.draw = function (oQRCode) {
+            var _elImage = this._elImage;
+            var _oContext = this._oContext;
+            var _htOption = this._htOption;
+            
+			var nCount = oQRCode.getModuleCount();
+			var nWidth = _htOption.width / nCount;
+			var nHeight = _htOption.height / nCount;
+			var nRoundedWidth = Math.round(nWidth);
+			var nRoundedHeight = Math.round(nHeight);
+
+			_elImage.style.display = "none";
+			this.clear();
+			
+			for (var row = 0; row < nCount; row++) {
+				for (var col = 0; col < nCount; col++) {
+					var bIsDark = oQRCode.isDark(row, col);
+					var nLeft = col * nWidth;
+					var nTop = row * nHeight;
+					_oContext.strokeStyle = bIsDark ? _htOption.colorDark : _htOption.colorLight;
+					_oContext.lineWidth = 1;
+					_oContext.fillStyle = bIsDark ? _htOption.colorDark : _htOption.colorLight;					
+					_oContext.fillRect(nLeft, nTop, nWidth, nHeight);
+					
+					// 안티 앨리어싱 방지 처리
+					_oContext.strokeRect(
+						Math.floor(nLeft) + 0.5,
+						Math.floor(nTop) + 0.5,
+						nRoundedWidth,
+						nRoundedHeight
+					);
+					
+					_oContext.strokeRect(
+						Math.ceil(nLeft) - 0.5,
+						Math.ceil(nTop) - 0.5,
+						nRoundedWidth,
+						nRoundedHeight
+					);
+				}
+			}
+			
+			this._bIsPainted = true;
+		};
+			
+		/**
+		 * Make the image from Canvas if the browser supports Data URI.
+		 */
+		Drawing.prototype.makeImage = function () {
+			if (this._bIsPainted) {
+				_safeSetDataURI.call(this, _onMakeImage);
+			}
+		};
+			
+		/**
+		 * Return whether the QRCode is painted or not
+		 * 
+		 * @return {Boolean}
+		 */
+		Drawing.prototype.isPainted = function () {
+			return this._bIsPainted;
+		};
+		
+		/**
+		 * Clear the QRCode
+		 */
+		Drawing.prototype.clear = function () {
+			this._oContext.clearRect(0, 0, this._elCanvas.width, this._elCanvas.height);
+			this._bIsPainted = false;
+		};
+		
+		/**
+		 * @private
+		 * @param {Number} nNumber
+		 */
+		Drawing.prototype.round = function (nNumber) {
+			if (!nNumber) {
+				return nNumber;
+			}
+			
+			return Math.floor(nNumber * 1000) / 1000;
+		};
+		
+		return Drawing;
+	})();
+	
+	/**
+	 * Get the type by string length
+	 * 
+	 * @private
+	 * @param {String} sText
+	 * @param {Number} nCorrectLevel
+	 * @return {Number} type
+	 */
+	function _getTypeNumber(sText, nCorrectLevel) {			
+		var nType = 1;
+		var length = _getUTF8Length(sText);
+		
+		for (var i = 0, len = QRCodeLimitLength.length; i <= len; i++) {
+			var nLimit = 0;
+			
+			switch (nCorrectLevel) {
+				case QRErrorCorrectLevel.L :
+					nLimit = QRCodeLimitLength[i][0];
+					break;
+				case QRErrorCorrectLevel.M :
+					nLimit = QRCodeLimitLength[i][1];
+					break;
+				case QRErrorCorrectLevel.Q :
+					nLimit = QRCodeLimitLength[i][2];
+					break;
+				case QRErrorCorrectLevel.H :
+					nLimit = QRCodeLimitLength[i][3];
+					break;
+			}
+			
+			if (length <= nLimit) {
+				break;
+			} else {
+				nType++;
+			}
+		}
+		
+		if (nType > QRCodeLimitLength.length) {
+			throw new Error("Too long data");
+		}
+		
+		return nType;
+	}
+
+	function _getUTF8Length(sText) {
+		var replacedText = encodeURI(sText).toString().replace(/\%[0-9a-fA-F]{2}/g, 'a');
+		return replacedText.length + (replacedText.length != sText ? 3 : 0);
+	}
+	
+	/**
+	 * @class QRCode
+	 * @constructor
+	 * @example 
+	 * new QRCode(document.getElementById("test"), "http://jindo.dev.naver.com/collie");
+	 *
+	 * @example
+	 * var oQRCode = new QRCode("test", {
+	 *    text : "http://naver.com",
+	 *    width : 128,
+	 *    height : 128
+	 * });
+	 * 
+	 * oQRCode.clear(); // Clear the QRCode.
+	 * oQRCode.makeCode("http://map.naver.com"); // Re-create the QRCode.
+	 *
+	 * @param {HTMLElement|String} el target element or 'id' attribute of element.
+	 * @param {Object|String} vOption
+	 * @param {String} vOption.text QRCode link data
+	 * @param {Number} [vOption.width=256]
+	 * @param {Number} [vOption.height=256]
+	 * @param {String} [vOption.colorDark="#000000"]
+	 * @param {String} [vOption.colorLight="#ffffff"]
+	 * @param {QRCode.CorrectLevel} [vOption.correctLevel=QRCode.CorrectLevel.H] [L|M|Q|H] 
+	 */
+	QRCode = function (el, vOption) {
+		this._htOption = {
+			width : 256, 
+			height : 256,
+			typeNumber : 4,
+			colorDark : "#000000",
+			colorLight : "#ffffff",
+			correctLevel : QRErrorCorrectLevel.H
+		};
+		
+		if (typeof vOption === 'string') {
+			vOption	= {
+				text : vOption
+			};
+		}
+		
+		// Overwrites options
+		if (vOption) {
+			for (var i in vOption) {
+				this._htOption[i] = vOption[i];
+			}
+		}
+		
+		if (typeof el == "string") {
+			el = document.getElementById(el);
+		}
+
+		if (this._htOption.useSVG) {
+			Drawing = svgDrawer;
+		}
+		
+		this._android = _getAndroid();
+		this._el = el;
+		this._oQRCode = null;
+		this._oDrawing = new Drawing(this._el, this._htOption);
+		
+		if (this._htOption.text) {
+			this.makeCode(this._htOption.text);	
+		}
+	};
+	
+	/**
+	 * Make the QRCode
+	 * 
+	 * @param {String} sText link data
+	 */
+	QRCode.prototype.makeCode = function (sText) {
+		this._oQRCode = new QRCodeModel(_getTypeNumber(sText, this._htOption.correctLevel), this._htOption.correctLevel);
+		this._oQRCode.addData(sText);
+		this._oQRCode.make();
+		this._el.title = sText;
+		this._oDrawing.draw(this._oQRCode);			
+		this.makeImage();
+	};
+	
+	/**
+	 * Make the Image from Canvas element
+	 * - It occurs automatically
+	 * - Android below 3 doesn't support Data-URI spec.
+	 * 
+	 * @private
+	 */
+	QRCode.prototype.makeImage = function () {
+		if (typeof this._oDrawing.makeImage == "function" && (!this._android || this._android >= 3)) {
+			this._oDrawing.makeImage();
+		}
+	};
+	
+	/**
+	 * Clear the QRCode
+	 */
+	QRCode.prototype.clear = function () {
+		this._oDrawing.clear();
+	};
+	
+	/**
+	 * @name QRCode.CorrectLevel
+	 */
+	QRCode.CorrectLevel = QRErrorCorrectLevel;
+})();

debian/patches/Make-name-of-nobody-group-configurable-and-use-nogro.patch

@@ -0,0 +1,60 @@
+From 8a9c5629214cd71e88a5ac9c1b639faad9fc4ec1 Mon Sep 17 00:00:00 2001
+From: Frederik Himpe <frederik@frehi.be>
+Date: Tue, 25 Feb 2025 13:49:23 +0100
+Subject: [PATCH] Make name of nobody group configurable and use nogroup on
+ Debian
+
+Fixes: https://pagure.io/freeipa/issue/9753
+
+Signed-off-by: Frederik Himpe <frederik@frehi.be>
+Reviewed-By: Alexander Bokovoy <abokovoy@redhat.com>
+---
+ ipaplatform/base/constants.py        | 1 +
+ ipaplatform/debian/constants.py      | 1 +
+ ipaserver/install/adtrustinstance.py | 6 ++++--
+ 3 files changed, 6 insertions(+), 2 deletions(-)
+
+diff --git a/ipaplatform/base/constants.py b/ipaplatform/base/constants.py
+index f1ef7efff..4c8038a84 100644
+--- a/ipaplatform/base/constants.py
++++ b/ipaplatform/base/constants.py
+@@ -124,6 +124,7 @@ class BaseConstantsNamespace:
+     NAMED_OPTIONS_VAR = "OPTIONS"
+     NAMED_OPENSSL_ENGINE = None
+     NAMED_ZONE_COMMENT = ""
++    NOBODY_GROUP = Group("nobody")
+     PKI_USER = User("pkiuser")
+     PKI_GROUP = Group("pkiuser")
+     # ntpd init variable used for daemon options
+diff --git a/ipaplatform/debian/constants.py b/ipaplatform/debian/constants.py
+index 7216694ad..f8ee8cf9f 100644
+--- a/ipaplatform/debian/constants.py
++++ b/ipaplatform/debian/constants.py
+@@ -29,5 +29,6 @@ class DebianConstantsNamespace(BaseConstantsNamespace):
+     ODS_USER = User("opendnssec")
+     ODS_GROUP = Group("opendnssec")
+     SECURE_NFS_VAR = "NEED_GSSD"
++    NOBODY_GROUP = Group("nogroup")
+ 
+ constants = DebianConstantsNamespace()
+diff --git a/ipaserver/install/adtrustinstance.py b/ipaserver/install/adtrustinstance.py
+index fd5a5a282..df2586ef1 100644
+--- a/ipaserver/install/adtrustinstance.py
++++ b/ipaserver/install/adtrustinstance.py
+@@ -123,9 +123,11 @@ def make_netbios_name(s):
+ def map_Guests_to_nobody():
+     env = {'LC_ALL': 'C'}
+     args = [paths.NET, '-s', '/dev/null', 'groupmap', 'add',
+-            'sid=S-1-5-32-546', 'unixgroup=nobody', 'type=builtin']
++            'sid=S-1-5-32-546',
++            'unixgroup="' + constants.NOBODY_GROUP + '"', 'type=builtin']
+ 
+-    logger.debug("Map BUILTIN\\Guests to a group 'nobody'")
++    logger.debug("Map BUILTIN\\Guests to a group '%s'",
++                 constants.NOBODY_GROUP)
+     ipautil.run(args, env=env, raiseonerr=False, capture_error=True)
+ 
+ 
+-- 
+2.48.1
+

debian/patches/Make-path-of-Samba-lock-directory-configurable-and-u.patch

@@ -0,0 +1,54 @@
+From 1e47185289fbbe29eedca82a4872d1d075b26c26 Mon Sep 17 00:00:00 2001
+From: Frederik Himpe <frederik@frehi.be>
+Date: Thu, 27 Feb 2025 11:28:30 +0100
+Subject: [PATCH] Make path of Samba lock directory configurable and use
+ /run/samba on Debian
+
+Signed-off-by: Frederik Himpe <frederik@frehi.be>
+Reviewed-By: Alexander Bokovoy <abokovoy@redhat.com>
+---
+ ipaplatform/base/paths.py            | 1 +
+ ipaplatform/debian/paths.py          | 1 +
+ ipaserver/install/adtrustinstance.py | 2 +-
+ 3 files changed, 3 insertions(+), 1 deletion(-)
+
+diff --git a/ipaplatform/base/paths.py b/ipaplatform/base/paths.py
+index 6a62d7bd0..f794aae6d 100644
+--- a/ipaplatform/base/paths.py
++++ b/ipaplatform/base/paths.py
+@@ -350,6 +350,7 @@ class BasePathNamespace:
+     KRA_CS_CFG_PATH = "/var/lib/pki/pki-tomcat/conf/kra/CS.cfg"
+     KRACERT_P12 = "/root/kracert.p12"
+     SAMBA_DIR = "/var/lib/samba"
++    SAMBA_LOCKDIR = "/var/lib/samba/lock"
+     SSSD_DB = "/var/lib/sss/db"
+     SSSD_MC_GROUP = "/var/lib/sss/mc/group"
+     SSSD_MC_PASSWD = "/var/lib/sss/mc/passwd"
+diff --git a/ipaplatform/debian/paths.py b/ipaplatform/debian/paths.py
+index 7a8099680..229f185f0 100644
+--- a/ipaplatform/debian/paths.py
++++ b/ipaplatform/debian/paths.py
+@@ -44,6 +44,7 @@ class DebianPathNamespace(BasePathNamespace):
+     OPENSSL_DIR = "/usr/lib/ssl"
+     OPENSSL_CERTS_DIR = "/usr/lib/ssl/certs"
+     OPENSSL_PRIVATE_DIR = "/usr/lib/ssl/private"
++    SAMBA_LOCKDIR = "/run/samba"
+     ETC_DEBIAN_VERSION = "/etc/debian_version"
+     # Old versions of freeipa wrote all trusted certificates to a single
+     # file, which is not supported by ca-certificates.
+diff --git a/ipaserver/install/adtrustinstance.py b/ipaserver/install/adtrustinstance.py
+index df2586ef1..bc3a282e6 100644
+--- a/ipaserver/install/adtrustinstance.py
++++ b/ipaserver/install/adtrustinstance.py
+@@ -962,7 +962,7 @@ class ADTRUSTInstance(service.Service):
+         # in /var/lib/samba and /var/lib/samba/private
+         for smbpath in (paths.SAMBA_DIR,
+                         os.path.join(paths.SAMBA_DIR, "private"),
+-                        os.path.join(paths.SAMBA_DIR, "lock")):
++                        paths.SAMBA_LOCKDIR):
+             if os.path.isdir(smbpath):
+                 tdb_files = [
+                     os.path.join(smbpath, tdb_file)
+-- 
+2.48.1
+

debian/patches/dnssec-race-wa.diff

@@ -0,0 +1,14 @@
+diff --git a/ipaserver/install/opendnssecinstance.py b/ipaserver/install/opendnssecinstance.py
+index 95029fd5e..9b800f509 100644
+--- a/ipaserver/install/opendnssecinstance.py
++++ b/ipaserver/install/opendnssecinstance.py
+@@ -306,6 +306,9 @@ class OpenDNSSECInstance(service.Service):
+ 
+     def __start(self):
+         self.restart()  # needed to reload conf files
++        import time
++        while not os.path.exists('/run/opendnssec/enforcer.sock'):
++            time.sleep(1)
+         tasks.run_ods_policy_import()
+         if self.kasp_db_file:
+             # regenerate zonelist.xml

debian/patches/fix-sssd-socket-activation.diff

@@ -0,0 +1,8 @@
+--- a/install/share/advise/legacy/sssd.conf.template
++++ b/install/share/advise/legacy/sssd.conf.template
+@@ -1,5 +1,4 @@
+ [sssd]
+-services = nss, pam
+ config_file_version = 2
+ domains = default
+ re_expression = (?P<name>.+)

debian/patches/map-ssh-service.diff

@@ -0,0 +1,10 @@
+--- a/ipaplatform/debian/services.py
++++ b/ipaplatform/debian/services.py
+@@ -37,6 +37,7 @@ debian_system_units['ods_signerd'] = deb
+ debian_system_units['rpcgssd'] = 'rpc-gssd.service'
+ debian_system_units['rpcidmapd'] = 'nfs-idmapd.service'
+ debian_system_units['smb'] = 'smbd.service'
++debian_system_units['sshd'] = 'ssh.service'
+ 
+ # Service classes that implement Debian family-specific behaviour
+ 

debian/patches/series

@@ -0,0 +1,10 @@
+# upstreamed
+
+# not upstreamable
+dnssec-race-wa.diff
+fix-sssd-socket-activation.diff
+
+# send upstream
+map-ssh-service.diff
+Make-path-of-Samba-lock-directory-configurable-and-u.patch
+Make-name-of-nobody-group-configurable-and-use-nogro.patch

debian/pydist-overrides

@@ -0,0 +1,7 @@
+dbus_python python3-dbus-python
+dogtag_pki pki-server
+ipaclient python3-ipaclient
+ipalib python3-ipalib
+ipaplatform python3-ipaplatform
+ipapython python3-ipapython
+jwcrypto python3-jwcrypto

debian/python3-ipaclient.install

@@ -0,0 +1,6 @@
+usr/lib/python*/dist-packages/ipaclient-*.egg-info
+usr/lib/python*/dist-packages/ipaclient/*.py
+usr/lib/python*/dist-packages/ipaclient/install/*.py
+usr/lib/python*/dist-packages/ipaclient/plugins/*.py
+usr/lib/python*/dist-packages/ipaclient/remote_plugins/*.py
+usr/lib/python*/dist-packages/ipaclient/remote_plugins/2_*/*.py

debian/python3-ipalib.install

@@ -0,0 +1,6 @@
+usr/lib/python*/dist-packages/ipalib-*.egg-info
+usr/lib/python*/dist-packages/ipalib/*
+usr/lib/python*/dist-packages/ipaplatform-*.egg-info
+usr/lib/python*/dist-packages/ipaplatform/*
+usr/lib/python*/dist-packages/ipapython-*.egg-info
+usr/lib/python*/dist-packages/ipapython/*

debian/python3-ipaserver.install

@@ -0,0 +1,48 @@
+usr/lib/python*/dist-packages/ipaserver-*.egg-info
+usr/lib/python*/dist-packages/ipaserver/__init__*
+usr/lib/python*/dist-packages/ipaserver/advise/*
+usr/lib/python*/dist-packages/ipaserver/custodia
+usr/lib/python*/dist-packages/ipaserver/dcerpc.py
+usr/lib/python*/dist-packages/ipaserver/dcerpc_common.py
+usr/lib/python*/dist-packages/ipaserver/dns_data_management*
+usr/lib/python*/dist-packages/ipaserver/dnssec/*
+usr/lib/python*/dist-packages/ipaserver/install/__init__.py
+usr/lib/python*/dist-packages/ipaserver/install/adtrust.py
+usr/lib/python*/dist-packages/ipaserver/install/adtrustinstance.py
+usr/lib/python*/dist-packages/ipaserver/install/bindinstance.py
+usr/lib/python*/dist-packages/ipaserver/install/ca.py
+usr/lib/python*/dist-packages/ipaserver/install/cainstance.py
+usr/lib/python*/dist-packages/ipaserver/install/certs.py
+usr/lib/python*/dist-packages/ipaserver/install/conncheck.py
+usr/lib/python*/dist-packages/ipaserver/install/custodiainstance.py
+usr/lib/python*/dist-packages/ipaserver/install/dns.py
+usr/lib/python*/dist-packages/ipaserver/install/dnskeysyncinstance.py
+usr/lib/python*/dist-packages/ipaserver/install/dogtag.py
+usr/lib/python*/dist-packages/ipaserver/install/dogtaginstance.py
+usr/lib/python*/dist-packages/ipaserver/install/dsinstance.py
+usr/lib/python*/dist-packages/ipaserver/install/httpinstance.py
+usr/lib/python*/dist-packages/ipaserver/install/installutils.py
+usr/lib/python*/dist-packages/ipaserver/install/ipa_*.py
+usr/lib/python*/dist-packages/ipaserver/install/ipactl.py
+usr/lib/python*/dist-packages/ipaserver/install/kra.py
+usr/lib/python*/dist-packages/ipaserver/install/krainstance.py
+usr/lib/python*/dist-packages/ipaserver/install/krbinstance.py
+usr/lib/python*/dist-packages/ipaserver/install/ldapupdate.py
+usr/lib/python*/dist-packages/ipaserver/install/odsexporterinstance.py
+usr/lib/python*/dist-packages/ipaserver/install/opendnssecinstance.py
+usr/lib/python*/dist-packages/ipaserver/install/otpdinstance.py
+usr/lib/python*/dist-packages/ipaserver/install/plugins
+usr/lib/python*/dist-packages/ipaserver/install/replication.py
+usr/lib/python*/dist-packages/ipaserver/install/schemaupdate.py
+usr/lib/python*/dist-packages/ipaserver/install/server/*
+usr/lib/python*/dist-packages/ipaserver/install/service.py
+usr/lib/python*/dist-packages/ipaserver/install/sysupgrade.py
+usr/lib/python*/dist-packages/ipaserver/install/upgradeinstance.py
+usr/lib/python*/dist-packages/ipaserver/masters.py
+usr/lib/python*/dist-packages/ipaserver/p11helper.py
+usr/lib/python*/dist-packages/ipaserver/plugins/*
+usr/lib/python*/dist-packages/ipaserver/rpcserver*
+usr/lib/python*/dist-packages/ipaserver/secrets/*
+usr/lib/python*/dist-packages/ipaserver/servroles*
+usr/lib/python*/dist-packages/ipaserver/topology*
+usr/lib/python*/dist-packages/ipaserver/wsgi.py*

debian/python3-ipatests.install

@@ -0,0 +1,2 @@
+usr/lib/python*/dist-packages/ipatests-*
+usr/lib/python*/dist-packages/ipatests/*

debian/python3-ipatests.lintian-overrides

@@ -0,0 +1,2 @@
+# no need to be executable
+python3-ipatests: script-not-executable usr/lib/python*/dist-packages/ipatests/test_integration/scripts/caless-create-pki

debian/rules

@@ -0,0 +1,134 @@
+#!/usr/bin/make -f 
+
+# Uncomment this to turn on verbose mode.
+#export DH_VERBOSE=1
+
+include /usr/share/dpkg/architecture.mk
+include /usr/share/dpkg/pkg-info.mk
+
+CFLAGS += -D_FORTIFY_SOURCE=2
+
+# build server only where nodejs is available
+#ifneq (,$(filter $(DEB_HOST_ARCH), amd64 arm64 armhf i386 mips mips64el mipsel ppc64 ppc64el s390x))
+#  ONLY_CLIENT=0
+#else
+  ONLY_CLIENT=1
+#endif
+
+DESTDIR=$(CURDIR)/debian/tmp
+
+export PYTHON=python3
+export am_cv_python_pythondir=/usr/lib/python3/dist-packages
+export am_cv_python_pyexecdir=/usr/lib/python3/dist-packages
+export systemdsystemunitdir=$(shell pkgconf --variable=systemdsystemunitdir systemd | sed s,^/,,)
+
+confflags = \
+	--libexecdir=/usr/lib/ \
+	--with-ipaplatform=debian \
+	--with-sysconfenvdir=/etc/default \
+	--disable-pylint \
+	--without-ipa-join-xml \
+	--without-jslint
+
+ifeq ($(ONLY_CLIENT), 1)
+confflags += --disable-server \
+	--without-ipatests
+else
+confflags += --enable-server \
+	--with-ipatests
+endif
+
+# For maintainer use only, generate a tarball:
+gentarball:
+	tar --transform 's,^,$(DEB_SOURCE)-$(DEB_VERSION_UPSTREAM)/,' \
+		--exclude './debian' --exclude-vcs \
+		-cJf ../$(DEB_SOURCE)_$(DEB_VERSION_UPSTREAM).orig.tar.xz .
+
+gencontrol:
+ifeq ($(ONLY_CLIENT), 1)
+	cat debian/control.stub \
+	debian/control.common \
+	> debian/control
+else
+	cat debian/control.stub \
+	debian/control.server-bdeps \
+	debian/control.common \
+	debian/control.server \
+	> debian/control
+endif
+
+override_dh_clean: gencontrol
+	dh_clean
+	rm -f po/*.gmo po/Makefile.hack po/POTFILES.in po/stamp-po
+	rm -rf contrib/completion/ipa.bash_completion daemons/ipa-version.h \
+	       install/ui/src/libs/loader.js m4
+	rm -f ipaplatform/override.py ipapython/version.py ipasetup.py
+
+override_dh_auto_configure: gencontrol
+	dh_auto_configure -- $(confflags)
+
+# tests would just fail, they need a proper environment with 389 running et al
+override_dh_auto_test:
+
+override_dh_auto_install:
+	dh_auto_install --max-parallel=1
+
+ifneq ($(ONLY_CLIENT), 1)
+	chmod 755 $(DESTDIR)/usr/lib/ipa/certmonger/*
+
+	touch $(DESTDIR)/usr/share/ipa/html/ca.crt
+	touch $(DESTDIR)/usr/share/ipa/html/kerberosauth.xpi
+	touch $(DESTDIR)/usr/share/ipa/html/krb.con
+	touch $(DESTDIR)/usr/share/ipa/html/krb.js
+	touch $(DESTDIR)/usr/share/ipa/html/krb5.ini
+	touch $(DESTDIR)/usr/share/ipa/html/krbrealm.con
+endif
+
+	mkdir -p $(DESTDIR)/usr/share/bash-completion/completions
+	mv $(DESTDIR)/etc/bash_completion.d/ipa $(DESTDIR)/usr/share/bash-completion/completions
+
+	# purge .la files
+	find $(CURDIR)/debian/tmp -name "*.la" -type f -exec rm -f "{}" \;
+	# purge precompiled .pyc/.pyo files
+	find $(CURDIR)/debian/tmp -name '*.py[c,o]' -exec rm '{}' ';'
+	# fix permissions
+	find $(CURDIR)/debian/tmp -name "*.mo" -type f -exec chmod -x "{}" \;
+	# remove files which are useful only for make uninstall
+	find $(CURDIR)/debian/tmp -wholename '*/dist-packages/*/install_files.txt' -exec rm '{}' \;
+	# fix the interpreter
+	find debian/tmp ! -name '*.pyc' -a ! -name '*.pyo' -a \
+	    -type f -exec grep -qsm1 '^#!.*\bpython' {} \; \
+	    -exec sed -i -e '1 s|^#!.*\bpython[^ ]*|#!/usr/bin/python3|' {} \;
+ifeq ($(ONLY_CLIENT), 0)
+	# remove ipasphinx for now
+	rm -r $(CURDIR)/debian/tmp/usr/lib/python3/dist-packages/ipasphinx*
+endif
+
+override_dh_missing:
+	dh_missing --fail-missing
+
+ifneq ($(ONLY_CLIENT), 1)
+override_dh_installsystemd:
+	dh_installsystemd -pfreeipa-server --no-enable ipa.service
+	dh_installsystemd -pfreeipa-server --no-enable ipa-dnskeysyncd.service
+	dh_installsystemd -pfreeipa-server --no-enable ipa-custodia.service
+	dh_installsystemd -pfreeipa-server --no-enable ipa-ods-exporter.service
+endif
+
+override_dh_fixperms:
+	dh_fixperms
+
+	# check needed to not fail arch-indep build which doesn't run dh_installdirs
+	if [ -d $(CURDIR)/debian/freeipa-server/etc/ipa/custodia ]; then \
+	    chmod 0700 $(CURDIR)/debian/freeipa-server/etc/ipa/custodia; \
+	    chmod 0700 $(CURDIR)/debian/freeipa-server/var/lib/ipa/backup; \
+	fi
+
+override_dh_gencontrol:
+	dh_gencontrol -- \
+	  -Vlib:Depends=$(shell dpkg-query -W -f '$${Depends}' librpm-dev \
+			| sed -E 's/.*(librpm[[:alnum:].-]+).*/\1/')
+
+%:
+	dh $@ --with python3
+#		--builddirectory=build

debian/source/format

@@ -0,0 +1,2 @@
+3.0 (quilt)
+

debian/source/lintian-overrides

@@ -0,0 +1,11 @@
+# missing-sources/dojo/*, see install/ui/src/dojo.profile.js
+freeipa source: source-is-missing [install/ui/build/dojo/dojo.js]
+
+# missing-sources/jquery-*.js
+freeipa source: source-is-missing [install/ui/src/libs/jquery.js]
+
+# missing-sources/build/*, see install/ui/src/build.profile.js
+freeipa source: source-is-missing [install/ui/util/build/build.js]
+
+# client doesn't run autopkgtests
+freeipa source: empty-debian-tests-control

debian/tests/control

@@ -0,0 +1,8 @@
+#Tests: server-install
+#Depends:
+# freeipa-server, freeipa-client, freeipa-server-dns,
+# sudo,
+#Restrictions:
+# allow-stderr,
+# isolation-container,
+# needs-root,